home *** CD-ROM | disk | FTP | other *** search
/ Ham Radio 2000 #2 / Ham Radio 2000 - Volume 2.iso / HAMV2 / TCP_IP / TNOS230S / PBBSCMD.C < prev    next >
Encoding:
C/C++ Source or Header  |  1997-09-06  |  62.6 KB  |  2,641 lines
  1. /* NOTE: because of size, the previous 'mailbox.c' has been
  2.  * split in 3 parts:
  3.  * pbbscmd.c, containing the 'pbbs' subcommands,
  4.  * mailbox.c, containing some user mailbox commands, and
  5.  * mailbox2.c, containing the remaining user commands.
  6.  * 921125 - WG7J
  7.  */
  8.  
  9. /* There are only two functions in this mailbox code that depend on the
  10.  * underlying protocol, namely mbx_getname() and dochat(). All the other
  11.  * functions can hopefully be used without modification on other stream
  12.  * oriented protocols than AX.25 or NET/ROM.
  13.  *
  14.  * SM0RGV 890506, most work done previously by W9NK
  15.  *
  16.  *** Changed 900114 by KA9Q to use newline mapping features in stream socket
  17.  *    interface code; everything here uses C eol convention (\n)
  18.  *
  19.  *    Numerous new commands and other changes by SM0RGV, 900120
  20.  *
  21.  * Gateway function now support outgoing connects with the user's call
  22.  * with inverted ssid. Users can connect to system alias as well...
  23.  * See also several mods in socket.c,ax25.c and others
  24.  * 11/15/91, WG7J/PA3DIS
  25.  *
  26.  * Userlogging, RM,VM and KM commands, and R:-line interpretation
  27.  * added 920307 and later, Johan. K. Reinalda, WG7J/PA3DIS
  28.  *
  29.  * Inactivity timeout-disconnect added 920325 and later - WG7J
  30.  *
  31.  */
  32. #include "global.h"
  33. #include "ctype.h"
  34. #include "commands.h"
  35. #ifndef MSDOS
  36. #include <time.h>
  37. #endif
  38. #ifdef  UNIX
  39. #include <sys/stat.h>
  40. #endif
  41. #include "timer.h"
  42. #include "proc.h"
  43. #include "socket.h"
  44. #include "usock.h"
  45. #include "session.h"
  46. #include "smtp.h"
  47. #include "ftpserv.h"
  48. #include "bm.h"
  49. #include "pool.h"
  50. #include "assoc.h"
  51.  
  52.  
  53. #if !defined(_lint)
  54. static char rcsid[] OPTIONAL = "$Id: pbbscmd.c,v 1.28 1997/09/07 00:31:16 root Exp root $";
  55. #endif
  56.  
  57. #ifdef MAILBOX
  58.  
  59. #ifdef MSDOS
  60. extern void mbmemory (void);
  61. #endif
  62.  
  63. #ifdef EXPIRY
  64. extern void Expiretick (void *);
  65. #endif
  66. extern char *mblookname (struct mbx * m, char *str);
  67. extern int dombmovemail (int argc, char *argv[], void *p);
  68. extern char *host_or_wpage_exp (char *to, int hier, int exphome, int *dns);
  69. extern char *wpage_exp (char *to, int hier, int exphome);
  70. extern char *permtest (char *path, long privs, const char *name, int mode, char *root, int thedir);
  71. extern int dombkickone (int argc, char *argv[], void *p);
  72.  
  73. extern char Myalias[];
  74. extern char MyBBS[AXALEN];
  75. #ifdef EXPIRY
  76. extern int ExpireActive;
  77. extern char *ExpireArea;
  78. extern time_t ExpireLast;
  79. #endif
  80. #ifdef MBFWD
  81. extern char *mbxRCall;
  82. #endif
  83. extern char *Mbhaddress;
  84.  
  85. extern int BbsUsers;
  86. extern int Totallogins, Tutorlogins[], BBSlogins;
  87. #ifdef CONVERS
  88. extern int Conflogins;
  89. #endif
  90. char *Mbprompt;
  91. char *MMotd;
  92. char *MExit;
  93. char *Mtmsg;
  94. char *MAttendedAt;
  95. int MOTDalways = 0;
  96. int MAttended = 0;
  97. int MBnoSubjBell = 0;
  98. int MBnoReturnReceipt = 0;
  99. int enforceBhosts = 0;
  100. int MBackfilter = 0;
  101. int LoginTimer = 180;
  102.  
  103. #ifdef EXPIRY
  104. #define HALFYEAR 182        /* used for expiring personal areas */
  105. int PruneAge = HALFYEAR;
  106. #endif
  107. char Mbpasswd[MAXPWDLEN + 1] = "";
  108. struct no_js *Exclude = (struct no_js *) NULL;
  109.  
  110. #ifdef ASKHOME
  111. static char *Mbhome = NULLCHAR;
  112. #endif
  113.  
  114. AarrayPtr Mbcustom = NULLASSOC;
  115.  
  116.  
  117. #ifdef MBFWD
  118. extern int MbForwarded;
  119. int Mbfullsvc = 1;
  120. #endif
  121.  
  122. #ifdef DELEGATE
  123. int Mbdelegate = 1;
  124. #endif
  125.  
  126. #ifdef AX25
  127. int Mbaxpasswd = 0;
  128. #endif
  129.  
  130. extern int MbSent;
  131. extern int MbRead;
  132. extern int MbRecvd;
  133.  
  134.  
  135. const char *continents[] =
  136. {
  137.     "euro", "medr", "indi", "mdle", "seas", "asia", "noam",
  138.     "ceam", "carb", "soam", "aunz", "epac", "npac", "spac",
  139.     "wpac", "nafr", "cafr", "safr", "antr"
  140. };
  141.  
  142. #define numcontinents 19
  143.  
  144.  
  145. #ifdef AX25
  146. static char Uplink[] = "Uplink  (%s)";
  147. static char Downlink[] = "Downlink (%s)";
  148. #endif
  149.  
  150. #ifdef NETROM
  151. static char incircuit[] = "Circuit (%s @ %s%s%s)";
  152. static char outcircuit[] = "Circuit (%s%s%s)";
  153. #endif
  154.  
  155. static char Telnet[] = "Telnet  (%s @ %s)";
  156. static char Telnetdown[] = "Telnet  (%s)";
  157. static char Local[] = "Local   (%s @ %s)";
  158.  
  159. const char *displayMBstatus (int state, int issysop);
  160. int isaPBBShost (char *str);
  161.  
  162. #ifdef USERLOG
  163. void updatedefaults (struct mbx * m, int homeonly);
  164. void askrealname (struct mbx * m, int initial);
  165. int dorealname (int argc, char *argv[], void *p);
  166. #endif
  167.  
  168. char *findhome (char *name);
  169. void askhome (struct mbx * m, int initial);
  170. int dobbshome (int argc, char *argv[], void *p);
  171. char *cmd_line (int argc, char *argv[], char stype);
  172. int dostr (int argc, char *argv[], const char *cmdstr, const char *label, char **str);
  173. static int dobbsdumperr (int argc, char *argv[], void *p);
  174. static int dombnewscan (int argc, char *argv[], void *p);
  175. static int dombarea (int argc, char *argv[], void *p);
  176. static int dombmore (int argc, char *argv[], void *p);
  177. static int dombnorreceipt (int argc, char *argv[], void *p);
  178.  
  179. #ifdef MAILCMDS
  180. static int dombscan (int argc, char *argv[], void *p);
  181. static int dombholdsumm (int argc, char *argv[], void *p);
  182. static int dopbbsreview (int argc, char *argv[], void *p);
  183. static int dombmport (int argc, char *argv[], void *p);
  184. static int dombbonly (int argc, char *argv[], void *p);
  185. static int dombsendquery (int argc, char *argv[], void *p);
  186. static int dombholdall (int argc, char *argv[], void *p);
  187. static int dombhold (int argc, char *argv[], void *p);
  188. static int dombnobid (int argc, char *argv[], void *p);
  189. #endif
  190.  
  191. static int dombalias (int argc, char *argv[], void *p);
  192. static int donewmotdfile (int argc, char *argv[], void *p);
  193. static int doattend (int argc, char *argv[], void *p);
  194.  
  195. static int dombnewuser (int argc, char *argv[], void *p);
  196. static int dombmotd (int argc, char *argv[], void *p);
  197. static int dombmotdalways (int argc, char *argv[], void *p);
  198. static int domexit (int argc, char *argv[], void *p);
  199. int dombusers (int argc, char *argv[], void *p);
  200. int dombpast (int argc, char *argv[], void *p);
  201. static int dojumpstart (int argc, char *argv[], void *p);
  202. static int dombnrid (int argc, char *argv[], void *p);
  203. static int dombsetpasswd (int argc, char *argv[], void *p);
  204. static int dombenforce (int argc, char *argv[], void *p);
  205. static int dombnoax25 (int argc, char *argv[], void *p);
  206. static int dombuonly (int argc, char *argv[], void *p);
  207. static int dombsonly (int argc, char *argv[], void *p);
  208. static int dombmaint (int argc, char *argv[], void *p);
  209. static int dombmaintstr (int argc, char *argv[], void *p);
  210. static int dombmaintmode (int argc, char *argv[], void *p);
  211. static int dombmaintclear (int argc, char *argv[], void *p);
  212. extern int dombmailfor (int argc, char *argv[], void *p);
  213. extern int dombstatus (int argc, char *argv[], void *p);
  214. int dombmailstats (int argc, char *argv[], void *p);
  215. static int dombtmsg (int argc, char *argv[], void *p);
  216. #ifdef EXPIRY
  217. static int dombprune (int argc, char *argv[], void *p);
  218. static int dombpruneage (int argc, char *argv[], void *p);
  219. static void mbpruning (int a, void *v1, void *v2);
  220. extern void expire (char *, int);
  221. #endif
  222. static int dombackfilter (int argc, char *argv[], void *p);
  223. static int domaildomain (int argc, char *argv[], void *p);
  224. static int dombremote (int argc, char *argv[], void *p);
  225. static int dombbump (int argc, char *argv[], void *p);
  226. static int dombzap (int argc, char *argv[], void *p);
  227. static int dombhideport (int argc, char *argv[], void *p);
  228. static int domblogging (int argc, char *argv[], void *p);
  229. static int dombmaxtimer (int argc, char *argv[], void *p);
  230. static int dombmaxusers (int argc, char *argv[], void *p);
  231. static int dombprompt (int argc, char *argv[], void *p);
  232. static int dombcmd (int argc, char *argv[], void *p);
  233. static int dombnosubjbell (int argc, char *argv[], void *p);
  234. static int doaxpasswd (int argc, char *argv[], void *p);
  235. static int domblogintimer (int argc, char *argv[], void *p);
  236.  
  237.  
  238. #ifdef STRICT_CALL
  239. static int dombstrict (int argc, char *argv[], void *p);
  240. #endif
  241.  
  242. #ifdef DELEGATE
  243. static int dombdelegate (int argc, char *argv[], void *p);
  244. #endif
  245.  
  246. extern void updateFwd (char *who, char *area, long bid, long size);
  247. extern void bbsbump (char *user, int zap);
  248.  
  249. #ifdef MBXTDISC
  250. static int dombtdisc (int argc, char *argv[], void *p);
  251. static int dombtdiscsysop (int argc, char *argv[], void *p);
  252. #endif
  253.  
  254. #ifdef ASKHOME
  255. static int dombhome (int argc, char *argv[], void *p);
  256. #endif
  257.  
  258. #ifdef MBFWD
  259. static int dombfullsvc (int argc, char *argv[], void *p);
  260. #endif
  261.  
  262. #ifdef CONVERS
  263. static int dombconvlink (int argc, char *argv[], void *p);
  264. #endif
  265.  
  266. #if defined(TIPMAIL) && defined(ALLSERV)
  267. static int dotimeout (int argc, char *argv[], void *p);
  268. #endif
  269.  
  270. #ifdef REJECT
  271. static int dombreject (int argc, char *argv[], void *p);
  272. #endif
  273.  
  274. #ifdef CATALOG
  275. #include "catalog.h"
  276.  
  277. #define CAT pbbscmd_catalog
  278.  
  279. #define bumpusage    __STR(0)
  280. #define zapusage    __STR(1)
  281. #define logging_str    __STR(2)
  282. #define holdall_str    __STR(3)
  283. #define maint_str    __STR(4)
  284. #define maintmode_str    __STR(5)
  285. #define maintclear_str    __STR(6)
  286. #define invalidcall    __STR(7)
  287. #define jumpstart_str    __STR(8)
  288. #define nrid_str    __STR(9)
  289. #define mbarea_str    __STR(10)
  290. #define scan_str    __STR(11)
  291. #define hold_str    __STR(12)
  292. #define fullsvc_str    __STR(13)
  293. #define delegate_str    __STR(14)
  294. #define nobid_str    __STR(15)
  295. #define query_str    __STR(16)
  296. #define convers_str    __STR(17)
  297. #define dumperr_str    __STR(18)
  298. #define attend_str    __STR(19)
  299. #define tdisc_str    __STR(20)
  300. #define tdiscsysop_str    __STR(21)
  301. #define maxtimer_str    __STR(22)
  302. #define maxusers_str    __STR(23)
  303. #define passwdusage    __STR(24)
  304. #define strusage    __STR(25)
  305. #define motdalways_str    __STR(26)
  306. #define allview_str    __STR(27)
  307. #define homeusage    __STR(28)
  308. #define promptusage    __STR(29)
  309. #define changehome_str    __STR(30)
  310. #define homeset_str    __STR(31)
  311. #define homesyntax    __STR(32)
  312. #define realname_as    __STR(33)
  313. #define realname_str    __STR(34)
  314. #define realname_change    __STR(35)
  315. #define realname_set    __STR(36)
  316. #define realname_syntax    __STR(37)
  317. #define past_header    __STR(38)
  318. #define queued_str    __STR(39)
  319. #define ms_logins    __STR(40)
  320. #define users_count    __STR(41)
  321. #define info_on        __STR(42)
  322. #define ipaddress_str    __STR(43)
  323. #define nolocal_str    __STR(44)
  324. #define message_oor    __STR(45)
  325. #define mr_syntax    __STR(46)
  326. #define fwd_daemon    __STR(47)
  327. #define tiptimeout_str    __STR(48)
  328. #ifdef CALLBOOK
  329. #define callusage    __STR(49)
  330. #endif
  331. #define usernoton    __STR(50)
  332. #define sysopchat    __STR(51)
  333. #define nosubj_str    __STR(52)
  334. #define enforce_str    __STR(53)
  335. #define maildomain_str    __STR(54)
  336. #define norreceipt_str    __STR(55)
  337. #define mbmore_str    __STR(56)
  338. #define ackfilter_str    __STR(57)
  339. #ifdef EXPIRY
  340. #define pruneage_str    __STR(58)
  341. #endif
  342. #define axpasswd_str    __STR(59)
  343. #define mbtimer_str    __STR(60)
  344.  
  345.  
  346. #else /* CATALOG */
  347.  
  348. static const char bumpusage[] = "Syntax: pbbs bump username\n";
  349. static const char zapusage[] = "Syntax: pbbs zap username\n";
  350. static const char logging_str[] = "Keep log of each PBBS login";
  351. static const char holdall_str[] = "Hold all local messages for SYSOP review";
  352. static const char maint_str[] = "BBS Maintenance";
  353. static const char maintmode_str[] = "Use BBS Maintenance mode";
  354. static const char maintclear_str[] = "Clear BBS (bump users) for BBS Maintenance mode";
  355. static const char invalidcall[] = "Invalid call: %s\n";
  356. static const char jumpstart_str[] = "Jump start on connect";
  357. static const char nrid_str[] = "Netrom id prompt";
  358. static const char mbarea_str[] = "New users get area indication in prompt";
  359. static const char scan_str[] = "New users get 'new mail scan' permission";
  360. static const char hold_str[] = "New users have mail entered held for review";
  361. static const char fullsvc_str[] = "Full Service BBS";
  362. static const char delegate_str[] = "Allow user delegation forwarding";
  363. static const char nobid_str[] = "Accept Buls without BID";
  364. static const char query_str[] = "Query after send";
  365. static const char convers_str[] = "PBBS convers";
  366. static const char dumperr_str[] = "BBS - Dump on error";
  367. static const char attend_str[] = "Mailbox Attended flag";
  368. static const char tdisc_str[] = "PBBS redundancy timer (sec)";
  369. static const char tdiscsysop_str[] = "PBBS redundancy timer used for Sysops";
  370. static const char maxtimer_str[] = "PBBS Maximum session time allowed (sec)";
  371. static const char maxusers_str[] = "Maximum PBBS incoming users (%d max)";
  372. static const char passwdusage[] = "Usage: pbbs password \"<sysop password>\"\n";
  373. static const char strusage[] = "Usage: %s %s \"<your message>\"\n";
  374. static const char motdalways_str[] = "Always display MOTD file";
  375. static const char allview_str[] = "All users will view the 'motd' file on their next login!\n";
  376. static const char homeusage[] = "Usage: pbbs home <your prompt string>\n";
  377. static const char promptusage[] = "Usage: pbbs prompt \"prompt string\"\n";
  378. static const char changehome_str[] = "\nChanging HOME BBS from '%s'! Enter name of new HOME...\n";
  379. static const char homeset_str[] = "\nHOME BBS set to '%s'\n";
  380. static const char homesyntax[] = "Syntax: HOME user @bbs\n";
  381. static const char realname_as[] = "\nThe on-line callbook shows your real name as '%s'\n";
  382. static const char realname_str[] = "Your real name is used along with your callsign when sending a message\n"
  383. "If you wish to %s this, use the NAME command\n";
  384. static const char realname_change[] = "\nChanging REAL NAME from '%s'!\nEnter the name you wish to be known by...\n";
  385. static const char realname_set[] = "\nREAL NAME set to '%s'\n";
  386. static const char realname_syntax[] = "Syntax: NAME user \"realname\"\n";
  387. static const char past_header[] = "Past users:\nUser       Logins  Time since last   User       Logins  Time since last\n";
  388. static const char queued_str[] = "SMTP queued messages: %d\n";
  389. static const char ms_logins[] = "Total Logins: %d   (BBS: %d";
  390. static const char users_count[] = "Users: %d\nCount: %d\n";
  391. static const char info_on[] = "Information on %s %s\n";
  392. static const char ipaddress_str[] = "%s's TCP/IP ADDRESS: %s\n";
  393. static const char nolocal_str[] = "No local data found for '%s'\n";
  394. static const char message_oor[] = "Message number out of range\n";
  395. static const char mr_syntax[] = "Syntax: MR type filename toname [fromname]\n";
  396. static const char fwd_daemon[] = "Forwarding Daemon: %s";
  397. static const char tiptimeout_str[] = "Tip connection timeout";
  398. #ifdef CALLBOOK
  399. static const char callusage[] = "Usage: callserver <host> <port>\n";
  400. #endif
  401. static const char usernoton[] = "User '%s' not on BBS!\n";
  402. static const char sysopchat[] = "\nSYSOP requests a chat.....\n\n";
  403. static const char nosubj_str[] = "Strip bell characters from subject lines";
  404. static const char enforce_str[] = "Enforce that all bulletins are sent with a '@host'";
  405. static const char maildomain_str[] = "Force user@host to use DNS hostname rather than WPages";
  406. static const char norreceipt_str[] = "Disable responses to Return Receipt requests";
  407. static const char mbmore_str[] = "New users get this value for 'more after' lines";
  408. static const char ackfilter_str[] = "Filter out all '/ack' lines in email messages";
  409. static const char pruneage_str[] = "Number of days to save messages when pruning";
  410. static const char axpasswd_str[] = "Require all non-anonyous, non-PBBS AX.25 users to provide password";
  411. static const char mbtimer_str[] = "Login timeout delay (in seconds)";
  412. #endif /* CATALOG */
  413.  
  414.  
  415.  
  416. static void smtpqueuecheck (void);
  417.  
  418. int Mbjumpstart = 1;
  419. int Usenrid = 0;
  420. int Usescan = 0;
  421. int Usearea = 1;
  422. int Usemore = 0;
  423. int Usehold = 0;
  424. int NoBid;
  425. int MbLogging = 0;
  426. static int PBBSmaildomain = 0;
  427. #ifdef STRICT_CALL
  428. int PBBSstrict = 0;
  429. #endif
  430. int MBXMaint = 0;
  431. int MBXMaintMode = 1;
  432. static int MBXMaintClear = 0;
  433. char *MBXMaintStr;
  434. int Mbsendquery = 1;
  435. char Mbnrid[20];
  436.  
  437. #ifdef MBXTDISC
  438. int32 Mbtdiscinit = 0;
  439. int MbtdiscSysop = 1;
  440. #endif
  441.  
  442. int32 mbxMaxTimer = 0;
  443. int mbxMaxUsers;
  444. extern int MbHoldall;
  445.  
  446. #ifdef REJECT
  447. int MbReject = 0;
  448. #endif
  449.  
  450.  
  451. /* pbbs subcommand table */
  452. static struct cmds Mbtab[] =
  453. {
  454.     { "ackfilter",    dombackfilter,    0,    0,    NULLCHAR },
  455.     { "alias",    dombalias,    0,    0,    NULLCHAR },
  456.     { "attend",    doattend,    0,    0,    NULLCHAR },
  457.     { "ax25passwd",    doaxpasswd,    0,    0,    NULLCHAR },
  458.     { "bbsdumperr",    dobbsdumperr,    0,    0,    NULLCHAR },
  459. #if defined(MAILCMDS) && defined(AX25)
  460.     { "bbsonly",    dombbonly,    0,    0,    NULLCHAR },
  461. #endif
  462.     { "bump",    dombbump,    0,    2,    "pbbs bump <bbsuser>" },
  463. #if defined(FOQ_CMDS) && defined(ALLSERV)
  464.     { "chat",    dombchat,    0,    2,    "pbbs chat <bbsuser>" },
  465. #endif
  466.     { "cmd",    dombcmd,    0,    0,    NULLCHAR },
  467. #ifdef CONVERS
  468.     { "convers",    dombconvlink,    0,    0,    NULLCHAR },
  469. #endif
  470. #ifdef MAILCMDS
  471. #ifdef DELEGATE
  472.     { "delegate",    dombdelegate,    0,    0,    NULLCHAR },
  473. #endif
  474.     { "enforce",    dombenforce,    0,    0,    NULLCHAR },
  475. #ifdef MBFWD
  476.     { "fullservice",dombfullsvc,    0,    0,    NULLCHAR },
  477. #endif
  478. #endif
  479. #ifdef MAILCMDS
  480.     { "holdsummary",dombholdsumm,    0,    0,    NULLCHAR },
  481. #endif
  482.     { "hideport",    dombhideport,    0,    0,    NULLCHAR },
  483. #ifdef MAILCMDS
  484.     { "holdall",    dombholdall,    0,    0,    NULLCHAR },
  485. #endif
  486. #ifdef ASKHOME
  487.     { "home",    dombhome,    0,    0,    NULLCHAR },
  488. #endif
  489. #ifdef AX25
  490.     { "jumpstart",    dojumpstart,    0,    0,    NULLCHAR },
  491. #endif
  492.     { "logging",    domblogging,    0,    0,    NULLCHAR },
  493.     { "logintimer",    domblogintimer,    0,    0,    NULLCHAR },
  494.     { "maildomain",    domaildomain,    0,    0,    NULLCHAR },
  495. #if defined(MAILFOR) && defined(AX25) && defined(MAILCMDS)
  496.     { "mailfor",    dombmailfor,    0,    0,    NULLCHAR },
  497. #endif
  498.     { "mailstats",    dombmailstats,    0,    0,    NULLCHAR },
  499.     { "maintenance",dombmaint,    0,    0,    NULLCHAR },
  500.     { "maintclear",    dombmaintclear,    0,    0,    NULLCHAR },
  501.     { "maintmode",    dombmaintmode,    0,    0,    NULLCHAR },
  502.     { "maintstr",    dombmaintstr,    0,    0,    NULLCHAR },
  503.     { "maxtimer",    dombmaxtimer,    0,    0,    NULLCHAR },
  504.     { "maxusers",    dombmaxusers,    0,    0,    NULLCHAR },
  505.     { "mexit",    domexit,    0,    0,    NULLCHAR },
  506.     { "motd",    dombmotd,    0,    0,    NULLCHAR },
  507.     { "motdalways",    dombmotdalways,    0,    0,    NULLCHAR },
  508. #if defined(AX25) && defined(MAILCMDS)
  509.     { "mport",    dombmport,    0,    0,    NULLCHAR },
  510. #endif
  511.     { "newuser",    dombnewuser,    0,    0,    NULLCHAR },
  512.     { "newmotdfile",donewmotdfile,    0,    0,    NULLCHAR },
  513. #ifdef AX25
  514.     { "noax25",    dombnoax25,    0,    0,    NULLCHAR },
  515. #endif
  516. #ifdef MAILCMDS
  517.     { "nobid",    dombnobid,    0,    0,    NULLCHAR },
  518. #endif
  519.     { "norreceipt",    dombnorreceipt,    0,    0,    NULLCHAR },
  520.     { "nosubjbell",    dombnosubjbell,    0,    0,    NULLCHAR },
  521.     { "past",    dombpast,    0,    0,    NULLCHAR },
  522.     { "password",    dombsetpasswd,    0,    0,    NULLCHAR },
  523.     { "prompt",    dombprompt,    0,    0,    NULLCHAR },
  524. #ifdef EXPIRY
  525.     { "prune",    dombprune,    0,    0,    NULLCHAR },
  526.     { "pruneage",    dombpruneage,    0,    0,    NULLCHAR },
  527. #endif
  528. #ifdef MAILCMDS
  529.     { "review",    dopbbsreview,    0,    0,    NULLCHAR },
  530. #endif
  531. #ifdef REJECT
  532.     { "reject",    dombreject,    0,    0,    NULLCHAR },
  533. #endif
  534.     { "remote",    dombremote,    0,    0,    NULLCHAR },
  535. #ifdef MAILCMDS
  536.     { "scan",    dombscan,    0,    2,    "pbbs scan <bbsuser>" },
  537.     { "sendquery",    dombsendquery,    0,    0,    NULLCHAR },
  538. #endif
  539.     { "status",    dombstatus,    0,    0,    NULLCHAR },
  540. #ifdef STRICT_CALL
  541.     { "strictcall",    dombstrict,    0,    0,    NULLCHAR },
  542. #endif
  543. #ifdef  AX25
  544.     { "sysoponly",    dombsonly,    0,    0,    NULLCHAR },
  545. #endif
  546. #ifdef MBXTDISC
  547.     { "tdisc",    dombtdisc,    0,    0,    NULLCHAR },
  548.     { "tdiscsysop",    dombtdiscsysop,    0,    0,    NULLCHAR },
  549. #endif
  550. #if defined(TIPMAIL) && defined(ALLSERV)
  551.     { "tiptimeout",    dotimeout,    0,    0,    NULLCHAR },
  552. #endif
  553.     { "tmsg",    dombtmsg,    0,    0,    NULLCHAR },
  554. #ifdef AX25
  555.     { "usersonly",    dombuonly,    0,    0,    NULLCHAR },
  556. #endif
  557.     { "zap",    dombzap,    0,    0,    NULLCHAR },
  558.     { NULLCHAR,    NULL,        0,    0,    NULLCHAR }
  559. };
  560.  
  561.  
  562.  
  563.  
  564. /* pbbs newuser subcommand table */
  565. static struct cmds Mbnewtab[] =
  566. {
  567.     { "area",    dombarea,    0,    0,    NULLCHAR },
  568. #ifdef MAILCMDS
  569.     { "hold",    dombhold,    0,    0,    NULLCHAR },
  570. #endif
  571.     { "more",    dombmore,    0,    0,    NULLCHAR },
  572. #ifdef AX25
  573.     { "nrid",    dombnrid,    0,    0,    NULLCHAR },
  574. #endif
  575.     { "scan",    dombnewscan,    0,    0,    NULLCHAR },
  576.     { NULLCHAR,    NULL,        0,    0,    NULLCHAR }
  577. };
  578.  
  579.  
  580.  
  581. /*set the mailbox netrom id*/
  582. void
  583. setmbnrid ()
  584. {
  585. char tmp[AXBUF];
  586. #ifdef NETROM
  587. char tmp2[AXBUF];
  588. #endif
  589. #ifndef AX25
  590. char *cp;
  591. #endif
  592.  
  593. #ifdef NETROM
  594.     if (Nr_iface != NULLIF) {    /* Use netrom call, and alias (if exists) */
  595.         if (*Myalias != '\0')
  596.             sprintf (Mbnrid, "%s:%s ", pax25 (tmp, Myalias), pax25 (tmp2, Nr_iface->hwaddr));
  597.         else
  598.             sprintf (Mbnrid, "%s ", pax25 (tmp, Nr_iface->hwaddr));
  599.         return;
  600.     }
  601.     /* Use Mycall, and alias (if exists) */
  602.     if (*Myalias != '\0')
  603.         sprintf (Mbnrid, "%s:%s ", pax25 (tmp, Myalias), pax25 (tmp2, Mycall));
  604.     else
  605. #endif
  606. #ifdef AX25
  607.         sprintf (Mbnrid, "%s ", pax25 (tmp, Mycall));
  608. #else
  609.         strncpy (Mbnrid, Hostname, 19);
  610.     if ((cp = strchr (Mbnrid, '.')) != NULLCHAR)
  611.         *cp = '\0';
  612. #endif
  613.     return;
  614. }
  615.  
  616.  
  617.  
  618. /*This is a dummy called from the main command interpreter,
  619.  *setup a mbx structure so dombusers() works correct - WG7J
  620.  */
  621. int
  622. dombstatus (int argc OPTIONAL, char *argv[] OPTIONAL, void *p OPTIONAL)
  623. {
  624. struct mbx m;
  625.  
  626.     m.privs = SYSOP_CMD;
  627.     m.stype = ' ';
  628.     return dombusers (0, NULL, &m);
  629. }
  630.  
  631.  
  632.  
  633. static int
  634. dombbump (int argc, char *argv[], void *p OPTIONAL)
  635. {
  636.     if (argc == 1)
  637.         tputs (bumpusage);
  638.     else
  639.         bbsbump (argv[1], 0);
  640.     return 0;
  641. }
  642.  
  643.  
  644.  
  645. static int
  646. dombzap (int argc, char *argv[], void *p OPTIONAL)
  647. {
  648.     if (argc == 1)
  649.         tputs (zapusage);
  650.     else
  651.         bbsbump (argv[1], 1);
  652.     return 0;
  653. }
  654.  
  655.  
  656.  
  657. int
  658. domaildomain (int argc, char *argv[], void *p OPTIONAL)
  659. {
  660.     return setbool (&PBBSmaildomain, maildomain_str, argc, argv);
  661. }
  662.  
  663.  
  664.  
  665. #ifdef STRICT_CALL
  666. int
  667. dombstrict (int argc, char *argv[], void *p OPTIONAL)
  668. {
  669.     return setbool (&PBBSstrict, "Allow login from callsigns, only", argc, argv);
  670. }
  671. #endif
  672.  
  673.  
  674.  
  675. int
  676. domblogging (int argc, char *argv[], void *p OPTIONAL)
  677. {
  678.     return setbool (&MbLogging, logging_str, argc, argv);
  679. }
  680.  
  681.  
  682.  
  683. int
  684. dombenforce (int argc, char *argv[], void *p OPTIONAL)
  685. {
  686.     return setbool (&enforceBhosts, enforce_str, argc, argv);
  687. }
  688.  
  689.  
  690.  
  691. int
  692. dombackfilter (int argc, char *argv[], void *p OPTIONAL)
  693. {
  694.     return setbool (&MBackfilter, ackfilter_str, argc, argv);
  695. }
  696.  
  697.  
  698.  
  699. #ifdef MAILCMDS
  700. int
  701. dombholdall (int argc, char *argv[], void *p OPTIONAL)
  702. {
  703.     return setbool (&MbHoldall, holdall_str, argc, argv);
  704. }
  705.  
  706.  
  707.  
  708. static int
  709. dombnobid (int argc, char *argv[], void *p OPTIONAL)
  710. {
  711.     return setbool (&NoBid, nobid_str, argc, argv);
  712. }
  713.  
  714.  
  715.  
  716. static int
  717. dombsendquery (int argc, char *argv[], void *p OPTIONAL)
  718. {
  719.     return setbool (&Mbsendquery, query_str, argc, argv);
  720. }
  721.  
  722.  
  723.  
  724. static int
  725. dombholdsumm (int argc OPTIONAL, char *argv[] OPTIONAL, void *p OPTIONAL)
  726. {
  727. struct mbx m;
  728.  
  729.     tputc ('\n');
  730.     m.privs = SYSOP_CMD;
  731.     m.stype = 'H';
  732.  
  733.     return doarea (0, NULLCHARP, &m);
  734. }
  735.  
  736.  
  737.  
  738. static int
  739. dombscan (int argc OPTIONAL, char *argv[], void *p OPTIONAL)
  740. {
  741. struct mbx m;
  742. char *buf;
  743. long perm;
  744.  
  745.     tputc ('\n');
  746.     m.privs = 0;
  747.     m.stype = ' ';
  748.     strncpy (m.name, argv[1], 20);
  749.     (void) strupr (m.name);
  750.  
  751.     if ((buf = userlookup (m.name, NULLCHARP, NULLCHARP, &perm, NULL)) != NULLCHAR)    {
  752.         m.privs = perm;
  753.         free (buf);
  754.     }
  755.  
  756.     quickscan (&m, 1, 1);
  757.     return 0;
  758. }
  759.  
  760.  
  761.  
  762. static int
  763. dopbbsreview (int argc OPTIONAL, char *argv[] OPTIONAL, void *p OPTIONAL)
  764. {
  765. struct mbx m;
  766. int oldflow = Command->flowmode;
  767.  
  768.     tputc ('\n');
  769.     m.privs = SYSOP_CMD | FTP_WRITE;
  770.     m.stype = ' ';
  771.     m.morerows = 0;
  772.     m.quickfile = (FILE *) -1;
  773.     m.sid = 0;
  774.     m.user = Curproc->output;
  775.     m.mfile = NULLFILE;
  776.     m.area[0] = 0;
  777.     strcpy (m.name, "sysop");
  778.     if (Curproc->input == Command->input)
  779.         Command->flowmode = 1;
  780.  
  781.     (void) dombreview (0, NULLCHARP, &m);
  782.  
  783.     Command->flowmode = oldflow;
  784.     return 0;
  785. }
  786. #endif
  787.  
  788.  
  789.  
  790. #ifdef REJECT
  791. int
  792. dombreject (int argc, char *argv[], void *p OPTIONAL)
  793. {
  794.     return setbool (&MbReject, "Process 'reject.dat' file", argc, argv);
  795. }
  796. #endif
  797.  
  798.  
  799.  
  800. int
  801. dombmaint (int argc, char *argv[], void *p OPTIONAL)
  802. {
  803.     return setbool (&MBXMaint, maint_str, argc, argv);
  804. }
  805.  
  806.  
  807.  
  808. int
  809. dombmaintmode (int argc, char *argv[], void *p OPTIONAL)
  810. {
  811.     return setbool (&MBXMaintMode, maintmode_str, argc, argv);
  812. }
  813.  
  814.  
  815.  
  816. int
  817. dombmaintclear (int argc, char *argv[], void *p OPTIONAL)
  818. {
  819.     return setbool (&MBXMaintClear, maintclear_str, argc, argv);
  820. }
  821.  
  822.  
  823.  
  824. int
  825. dopbbs (int argc, char *argv[], void *p)
  826. {
  827.     if (argc == 1)
  828.         return dombstatus (0, NULL, NULL);
  829.     return subcmd (Mbtab, argc, argv, p);
  830. }
  831.  
  832.  
  833.  
  834. int
  835. dombnewuser (int argc, char *argv[], void *p)
  836. {
  837.     return subcmd (Mbnewtab, argc, argv, p);
  838. }
  839.  
  840.  
  841.  
  842. #ifdef AX25
  843.  
  844. static int
  845. dombhideport (int argc, char *argv[], void *p)
  846. {
  847.     return (dosetflag (argc, argv, p, HIDE_PORT, 1));
  848. }
  849.  
  850.  
  851.  
  852. static int
  853. dojumpstart (int argc, char *argv[], void *p OPTIONAL)
  854. {
  855. register int i;
  856. char tmp[AXBUF];
  857. struct no_js *ep;
  858.  
  859.     if ((argc > 1) && (*argv[1] == 'e')) {
  860.         /*the exclude subcommand*/
  861.         if (argc == 2) {    /* just list them */
  862.             for (ep = Exclude; ep != (struct no_js *) NULL; ep = ep->next)
  863.                 tprintf ("%s ", pax25 (tmp, ep->call));
  864.             tputc ('\n');
  865.         } else {        /* add some call(s) */
  866.             for (i = 0; i < argc - 2; i++) {
  867.                 ep = callocw (1, sizeof (struct no_js));
  868.  
  869.                 if (setcall (ep->call, argv[i + 2]) == -1) {
  870.                     tprintf (invalidcall, argv[i + 2]);
  871.                     free (ep);
  872.                 } else {    /* add to list */
  873.                     ep->next = Exclude;
  874.                     Exclude = ep;
  875.                 }
  876.             }
  877.         }
  878.         return 0;
  879.     }
  880.     return setbool (&Mbjumpstart, jumpstart_str, argc, argv);
  881. }
  882.  
  883.  
  884.  
  885. static int
  886. dombnrid (int argc, char *argv[], void *p OPTIONAL)
  887. {
  888.     return setbool (&Usenrid, nrid_str, argc, argv);
  889. }
  890.  
  891.  
  892.  
  893. #ifdef MAILCMDS
  894. static int
  895. dombmport (int argc, char *argv[], void *p)
  896. {
  897.     return (dosetflag (argc, argv, p, MAIL_BEACON, 1));
  898. }
  899.  
  900.  
  901.  
  902. static int
  903. dombhold (int argc, char *argv[], void *p OPTIONAL)
  904. {
  905.     return setbool (&Usehold, hold_str, argc, argv);
  906. }
  907. #endif
  908.  
  909.  
  910.  
  911. static int
  912. dombnoax25 (int argc, char *argv[], void *p)
  913. {
  914.     return (dosetflag (argc, argv, p, NO_AX25, 1));
  915. }
  916. #endif /* AX25 */
  917.  
  918.  
  919.  
  920. static int
  921. dombarea (int argc, char *argv[], void *p OPTIONAL)
  922. {
  923.     return setbool (&Usearea, mbarea_str, argc, argv);
  924. }
  925.  
  926.  
  927.  
  928. static int
  929. domblogintimer (int argc, char *argv[], void *p OPTIONAL)
  930. {
  931.     return setint (&LoginTimer, mbtimer_str, argc, argv);
  932. }
  933.  
  934.  
  935.  
  936. static int
  937. dombmore (int argc, char *argv[], void *p OPTIONAL)
  938. {
  939.     return setint (&Usemore, mbmore_str, argc, argv);
  940. }
  941.  
  942.  
  943.  
  944. static int
  945. dombnewscan (int argc, char *argv[], void *p OPTIONAL)
  946. {
  947.     return setbool (&Usescan, scan_str, argc, argv);
  948. }
  949.  
  950.  
  951.  
  952. static int
  953. dombnosubjbell (int argc, char *argv[], void *p OPTIONAL)
  954. {
  955.     return setbool (&MBnoSubjBell, nosubj_str, argc, argv);
  956. }
  957.  
  958.  
  959.  
  960. static int
  961. dombnorreceipt (int argc, char *argv[], void *p OPTIONAL)
  962. {
  963.     return setbool (&MBnoReturnReceipt, norreceipt_str, argc, argv);
  964. }
  965.  
  966.  
  967.  
  968. #ifdef MBFWD
  969. static int
  970. dombfullsvc (int argc, char *argv[], void *p OPTIONAL)
  971. {
  972.     return setbool (&Mbfullsvc, fullsvc_str, argc, argv);
  973. }
  974. #endif
  975.  
  976.  
  977.  
  978. static int
  979. doaxpasswd (int argc, char *argv[], void *p OPTIONAL)
  980. {
  981.     return setbool (&Mbaxpasswd, axpasswd_str, argc, argv);
  982. }
  983.  
  984.  
  985.  
  986. #ifdef DELEGATE
  987. static int
  988. dombdelegate (int argc, char *argv[], void *p OPTIONAL)
  989. {
  990.     return setbool (&Mbdelegate, delegate_str, argc, argv);
  991. }
  992. #endif
  993.  
  994.  
  995.  
  996. #ifdef CONVERS
  997. int Mbconverse = 1;
  998.  
  999. static int
  1000. dombconvlink (int argc, char *argv[], void *p OPTIONAL)
  1001. {
  1002.     return setbool (&Mbconverse, convers_str, argc, argv);
  1003. }
  1004. #endif
  1005.  
  1006.  
  1007.  
  1008. int BBSdump = 1;
  1009.  
  1010. static int
  1011. dobbsdumperr (int argc, char *argv[], void *p OPTIONAL)
  1012. {
  1013.     return setbool (&BBSdump, dumperr_str, argc, argv);
  1014. }
  1015.  
  1016.  
  1017.  
  1018. /* if unattended mode is set, ax25, telnet and maybe other sessions will
  1019.  * be restricted.
  1020.  */
  1021. static int
  1022. doattend (int argc, char *argv[], void *p OPTIONAL)
  1023. {
  1024.     return setbool (&MAttended, attend_str, argc, argv);
  1025. }
  1026.  
  1027.  
  1028.  
  1029. #ifdef MBXTDISC
  1030. /* Set mailbox redundancy timer */
  1031. static int
  1032. dombtdisc (int argc, char *argv[], void *p OPTIONAL)
  1033. {
  1034.     return setlong (&Mbtdiscinit, tdisc_str, argc, argv);
  1035. }
  1036.  
  1037.  
  1038.  
  1039. /* Set mailbox redundancy timer mode for sysops */
  1040. static int
  1041. dombtdiscsysop (int argc, char *argv[], void *p OPTIONAL)
  1042. {
  1043.     return setbool (&MbtdiscSysop, tdiscsysop_str, argc, argv);
  1044. }
  1045. #endif
  1046.  
  1047.  
  1048.  
  1049. /* Set mailbox maximum session timer */
  1050. static int
  1051. dombmaxtimer (int argc, char *argv[], void *p OPTIONAL)
  1052. {
  1053.     return setlong (&mbxMaxTimer, maxtimer_str, argc, argv);
  1054. }
  1055.  
  1056.  
  1057.  
  1058. /* Set mailbox maximum user count */
  1059. static int
  1060. dombmaxusers (int argc, char *argv[], void *p OPTIONAL)
  1061. {
  1062. char buf[50];
  1063.  
  1064.     sprintf (buf, maxusers_str, NUMMBX);
  1065.     return setint (&mbxMaxUsers, buf, argc, argv);
  1066. }
  1067.  
  1068.  
  1069.  
  1070. static int
  1071. dombsetpasswd (int argc, char *argv[], void *p OPTIONAL)
  1072. {
  1073. int len;
  1074.  
  1075.     /*Only allowed from keyboard*/
  1076.     if (Curproc->input != Command->input) {
  1077.         tputs (Noperm);
  1078.         return 0;
  1079.     }
  1080.     if (argc != 2) {
  1081.         tputs (passwdusage);
  1082.         return 0;
  1083.     }
  1084.     if ((len = (int) strlen (argv[1])) == 0)
  1085.         return 0;    /* zero length, don't reset */
  1086.  
  1087.     if (len > MAXPWDLEN) {
  1088.         tputs ("Too long\n");
  1089.         return 0;
  1090.     }
  1091.     strncpy (Mbpasswd, argv[1], MAXPWDLEN);
  1092.     return 0;
  1093. }
  1094.  
  1095.  
  1096.  
  1097. /* define the BBS alias*/
  1098. static int
  1099. dombalias (int argc, char *argv[], void *p OPTIONAL)
  1100. {
  1101. char tmp[AXBUF];
  1102.  
  1103.     if (argc < 2) {
  1104.         tprintf ("%s\n", pax25 (tmp, MyBBS));
  1105.         return 0;
  1106.     }
  1107.     if (setcall (MyBBS, argv[1]) == -1) {
  1108.         tputs ("can't set BBS alias\n");
  1109.         return 0;
  1110.     }
  1111.     return 0;
  1112. }
  1113.  
  1114.  
  1115.  
  1116. int
  1117. dostr (int argc, char *argv[], const char *cmdstr, const char *label, char **str)
  1118. {
  1119.     if (argc > 2) {
  1120.         tprintf (strusage, (cmdstr) ? cmdstr : "pbbs", label);
  1121.         return 0;
  1122.     }
  1123.     if (argc < 2) {
  1124.         if (*str != NULLCHAR) {
  1125.             tputs (*str);
  1126.             if (str[0][strlen (*str) - 1] != '\n')
  1127.                 tputs ("\n");
  1128.         }
  1129.     } else {
  1130.         if (*str != NULLCHAR) {
  1131.             free (*str);
  1132.             *str = NULLCHAR;    /* reset the pointer */
  1133.         }
  1134.         if (!strlen (argv[1]))
  1135.             return 0;    /* clearing the buffer */
  1136.         *str = mallocw (strlen (argv[1]) + 5);    /* allow for the EOL char */
  1137.         strcpy (*str, argv[1]);
  1138.         strcat (*str, "\n");    /* add the EOL char */
  1139.     }
  1140.     return 0;
  1141. }
  1142.  
  1143.  
  1144.  
  1145. static int
  1146. dombmaintstr (int argc, char *argv[], void *p OPTIONAL)
  1147. {
  1148.     return dostr (argc, argv, NULLCHAR, "maintstr", &MBXMaintStr);
  1149. }
  1150.  
  1151.  
  1152.  
  1153. static int
  1154. dombmotd (int argc, char *argv[], void *p OPTIONAL)
  1155. {
  1156.     return dostr (argc, argv, NULLCHAR, "motd", &MMotd);
  1157. }
  1158.  
  1159.  
  1160.  
  1161. static int
  1162. dombmotdalways (int argc, char *argv[], void *p OPTIONAL)
  1163. {
  1164.     return setbool (&MOTDalways, motdalways_str, argc, argv);
  1165. }
  1166.  
  1167.  
  1168.  
  1169. static int
  1170. dombremote (int argc, char *argv[], void *p OPTIONAL)
  1171. {
  1172.     return dostr (argc, argv, NULLCHAR, "remote", &MAttendedAt);
  1173. }
  1174.  
  1175.  
  1176.  
  1177. static int
  1178. donewmotdfile (int argc OPTIONAL, char *argv[] OPTIONAL, void *p OPTIONAL)
  1179. {
  1180. #ifdef USERLOG
  1181. FILE *Ufile, *tfile;
  1182. char buf[256], *cp;
  1183.  
  1184.     /* Save old defaults file to backup */
  1185.     unlink (UDefbak);
  1186.     if (rename (UDefaults, UDefbak))
  1187.         return 0;
  1188.     if ((tfile = fopen (UDefbak, "r")) != NULLFILE) {
  1189.         if ((Ufile = fopen (UDefaults, "w")) == NULLFILE) {
  1190.             (void) fclose (tfile);
  1191.             return 0;
  1192.         }
  1193.         while (fgets (buf, sizeof (buf), tfile) != NULLCHAR) {
  1194.             if ((cp = strchr (buf, ' ')) != NULLCHAR)
  1195.                 if ((cp = strchr (cp, ' ')) != NULLCHAR)
  1196.                     if ((cp = strchr (cp, ')')) != NULLCHAR)
  1197.                         if ((cp = strchr (cp, 'R')) != NULLCHAR)
  1198.                             *cp = ' ';
  1199.             fputs (buf, Ufile);
  1200.         }
  1201.         (void) fclose (tfile);
  1202.         (void) fclose (Ufile);
  1203.         tputs (allview_str);
  1204.     } else
  1205.         (void) rename (UDefbak, UDefaults);
  1206.     return 0;
  1207. #endif
  1208. }
  1209.  
  1210.  
  1211.  
  1212. static int
  1213. domexit (int argc, char *argv[], void *p OPTIONAL)
  1214. {
  1215.     return dostr (argc, argv, NULLCHAR, "mexit", &MExit);
  1216. }
  1217.  
  1218.  
  1219.  
  1220. static int
  1221. dombtmsg (int argc, char *argv[], void *p OPTIONAL)
  1222. {
  1223.     return dostr (argc, argv, NULLCHAR, "tmsgs", &Mtmsg);
  1224. }
  1225.  
  1226.  
  1227.  
  1228. #ifdef ASKHOME
  1229. /* Set the HOME BBS prompt string to be used */
  1230. static int
  1231. dombhome (int argc, char *argv[], void *p OPTIONAL)
  1232. {
  1233.     if (argc > 2) {
  1234.         tputs (homeusage);
  1235.         return 0;
  1236.     }
  1237.     if (argc < 2) {
  1238.         if (Mbhome != NULLCHAR)
  1239.             tprintf ("%s\n", Mbhome);
  1240.     } else {
  1241.         if (Mbhome != NULLCHAR) {
  1242.             free (Mbhome);
  1243.             Mbhome = NULLCHAR;    /* reset the pointer */
  1244.         }
  1245.         if (!strlen (argv[1]))
  1246.             return 0;    /* clearing the buffer */
  1247.         Mbhome = strdup (argv[1]);
  1248.     }
  1249.     return 0;
  1250. }
  1251. #endif /* ASKHOME */
  1252.  
  1253.  
  1254.  
  1255. /* Set a custom BBS prompt string*/
  1256. static int
  1257. dombprompt (int argc, char *argv[], void *p OPTIONAL)
  1258. {
  1259.     if (argc > 2)
  1260.         tputs (promptusage);
  1261.     else if (argc < 2) {
  1262.         if (Mbprompt != NULLCHAR)
  1263.             tprintf ("%s\n", Mbprompt);
  1264.     } else {
  1265.         if (Mbprompt != NULLCHAR) {
  1266.             free (Mbprompt);
  1267.             Mbprompt = NULLCHAR;    /* reset the pointer */
  1268.         }
  1269.         if (!strlen (argv[1]))
  1270.             return 0;    /* clearing the buffer */
  1271.         Mbprompt = strdup (argv[1]);
  1272.     }
  1273.     return 0;
  1274. }
  1275.  
  1276.  
  1277.  
  1278. /* Keep track of all past users */
  1279. struct pu {
  1280.     struct pu *next;    /* next one in list */
  1281.     char name[20];        /* user name */
  1282.     int32 time;        /* When was the last login ? */
  1283.     int number;        /* Number of times logged in */
  1284. };
  1285.  
  1286.  
  1287.  
  1288. #define NULLPU (struct pu *)NULL
  1289. static struct pu *Pu = NULLPU;
  1290.  
  1291. static struct pu *pu_lookup (char *name);
  1292.  
  1293. #ifdef POOLED
  1294. static struct mempool Pu_pool = {NULLPOOLBLK, NULLPOOLBLK, 0, sizeof (struct pu), 50};
  1295. #endif
  1296.  
  1297.  
  1298.  
  1299. /* Look up an entry in the users-list*/
  1300. static struct pu *
  1301. pu_lookup (char *name)
  1302. {
  1303. register struct pu *ppu;
  1304. struct pu *pulast = NULLPU;
  1305.  
  1306.     for (ppu = Pu; ppu != NULLPU; pulast = ppu, ppu = ppu->next) {
  1307.         if (!strcmp (name, ppu->name)) {    /* found it! */
  1308.             if (pulast != NULLPU) {
  1309.                 /* Move entry to top of list */
  1310.                 pulast->next = ppu->next;
  1311.                 ppu->next = Pu;
  1312.                 Pu = ppu;
  1313.             }
  1314.             return ppu;
  1315.         }
  1316.     }
  1317.     return NULLPU;
  1318. }
  1319.  
  1320.  
  1321.  
  1322. /*Log all users of the mailbox*/
  1323. /* This gets kept track of in the file name UDefaults */
  1324. /* format is
  1325. user @home (realname) datestamp options
  1326. where options are separated by spaces
  1327. M# - use more with # lines
  1328. A - use area indiation
  1329. X - use expert status
  1330. N - use netrom lookalike prompt
  1331. R - has the motd file been read?
  1332. S - give new message statistics on login
  1333. L - use LZW compressed streams
  1334. G - use ANSI color graphics
  1335. D - forwarding delegation enabled?
  1336. Cx - Connection type x (A=AX.25, N=NET/ROM, T=TELNET)
  1337. */
  1338.  
  1339. #ifdef USERLOG
  1340.  
  1341. /* Write the new defaults - WG7J */
  1342. void
  1343. updatedefaults (struct mbx *m, int homeonly)
  1344. {
  1345. FILE *Ufile, *tfile;
  1346. char buf[256];
  1347. char *cp, *cp2;
  1348. time_t t;
  1349.  
  1350.     /* Save old defaults file to backup */
  1351.     unlink (UDefbak);
  1352.     if (rename (UDefaults, UDefbak))
  1353.         return;
  1354.  
  1355.     /*Write all users back, but update this one!*/
  1356.     if ((Ufile = fopen (UDefaults, "w")) == NULLFILE) {
  1357.         /* Can't create defaults file ???*/
  1358.         (void) rename (UDefbak, UDefaults);
  1359.         return;
  1360.     }
  1361.     if ((tfile = fopen (UDefbak, "r")) == NULLFILE) {
  1362.         /* What on earth happened ???? */
  1363.         (void) fclose (Ufile);
  1364.         (void) rename (UDefbak, UDefaults);
  1365.         return;
  1366.     }
  1367.     while (fgets (buf, sizeof (buf), tfile) != NULLCHAR) {
  1368.         if ((cp = strchr (buf, ' ')) == NULLCHAR)
  1369.             continue;
  1370.         *cp = '\0';
  1371.         if (!stricmp (m->name, buf)) {
  1372.             /*found this user*/
  1373.             (void) time (&t);
  1374.             if (homeonly == 1) {
  1375.                 if ((cp = strchr (++cp, ' ')) == NULLCHAR)
  1376.                     continue;
  1377.                 cp++;
  1378.                 if (*cp == '@') {
  1379.                     if ((cp = strchr (++cp, ' ')) == NULLCHAR)
  1380.                         continue;
  1381.                     cp++;
  1382.                 }
  1383.                 cp = strdup (cp);
  1384.                 sprintf (buf, "%s %s %s", m->name, m->home, cp);
  1385.                 free (cp);
  1386.             } else if (homeonly == 2) {
  1387.                 *cp = ' ';
  1388.                 if ((cp = strchr (++cp, ' ')) == NULLCHAR)
  1389.                     continue;
  1390.                 *cp++ = 0;
  1391.                 if (*cp == '(') {
  1392.                     if ((cp = strchr (++cp, ')')) == NULLCHAR)
  1393.                         continue;
  1394.                     cp += 2;
  1395.                 }
  1396.                 cp = strdup (cp);
  1397.                 cp2 = strdup (buf);
  1398.                 sprintf (buf, "%s (%s) %s", cp2, m->realname, cp);
  1399.                 free (cp);
  1400.                 free (cp2);
  1401.             } else {
  1402.                 char *tmpcp = 0, *tmpcp2, *tmpcp3 = 0;
  1403.  
  1404.                 if (m->home) {
  1405.                     tmpcp3 = tmpcp = strdup (m->home);
  1406.                     tmpcp2 = strchr (tmpcp, '@');
  1407.                     if (tmpcp2)
  1408.                         tmpcp3 = ++tmpcp2;
  1409.                     tmpcp2 = strchr (tmpcp3, '.');
  1410.                     if (tmpcp2)
  1411.                         *tmpcp2 = 0;
  1412.                 }
  1413.                 sprintf (buf, "%s @%s %s %lu M%d %s%s%s%s%s%s%s%s%s C%c\n",
  1414.                      m->name,
  1415.                      (m->home && Hostname && strnicmp (m->home, Hostname, strlen (m->home)))
  1416.                      ? tmpcp3 : "",
  1417.                      (m->realname) ? m->realname : "()",
  1418.                      t, m->morerows,
  1419.                      (m->sid & MBX_AREA) ? "A" : "",
  1420.                      (m->sid & MBX_DELEGATE) ? "D" : "",
  1421.                      (m->sid & MBX_GFX) ? "G" : "",
  1422.                      (m->sid & MBX_HOLD) ? "H" : "",
  1423.                      (m->sid & MBX_TNOS) ? "L" : "",
  1424.                      (m->sid & MBX_NRID) ? "N" : "",
  1425.                      (m->sid & MBX_RDMOTD) ? "R" : "",
  1426.                      (m->sid & MBX_STATS) ? "S" : "",
  1427.                      (m->sid & MBX_EXPERT) ? "X" : "",
  1428.                      (m->family == AF_AX25) ? 'A' : \
  1429.                      ((m->family == AF_NETROM) ? 'N' : 'T'));
  1430.                 if (m->home)
  1431.                     free (tmpcp);
  1432.             }
  1433.         } else
  1434.             *cp = ' ';    /* restore the space !*/
  1435.         fputs (buf, Ufile);
  1436.     }
  1437.     (void) fclose (tfile);
  1438.     (void) fclose (Ufile);
  1439.     return;
  1440. }
  1441. #endif /* USERLOG */
  1442.  
  1443.  
  1444.  
  1445. #ifdef ASKHOME
  1446. char *
  1447. findhome (char *name)
  1448. {
  1449. char buf[256];
  1450. register char *cp, *cp2;
  1451. char *retval = (char *) 0;
  1452. register FILE *Ufile;
  1453.  
  1454.     if ((Ufile = fopen (UDefaults, "r")) != NULLFILE) {
  1455.         while (fgets (buf, sizeof (buf), Ufile) != NULLCHAR) {
  1456.             if ((cp = strchr (buf, ' ')) == NULLCHAR)
  1457.                 continue;
  1458.             *cp++ = '\0';
  1459.             if (!stricmp (name, buf)) {
  1460.                 if ((cp2 = strchr (cp, ' ')) != NULLCHAR)
  1461.                     *cp2 = '\0';
  1462.                 if (*cp == '@') {
  1463.                     cp++;
  1464.                     if ((cp2 = strchr (cp, '.')) != NULLCHAR)
  1465.                         *cp2 = '\0';
  1466.                     if (!*cp)
  1467.                         retval = (char *) -1;    /* -1 means home is here */
  1468.                     else if (*cp != '-')
  1469.                         retval = (char *) strdup (cp);
  1470.                 }
  1471.                 break;
  1472.             }
  1473.         }
  1474.         (void) fclose (Ufile);
  1475.     }
  1476.     return (retval);
  1477. }
  1478. #endif /* ASKHOME */
  1479.  
  1480.  
  1481.  
  1482. void 
  1483. askhome (struct mbx *m OPTIONAL, int initial OPTIONAL)
  1484. {
  1485. #ifdef ASKHOME
  1486. char *cp;
  1487. char name[80], here[AXBUF];
  1488.  
  1489.     if (initial && m->privs & IS_BBS) {
  1490.         m->home = strdup (m->name);
  1491.         return;
  1492.     }
  1493. #ifdef MBFWD
  1494.     if (mbxRCall)
  1495.         strncpy (here, mbxRCall, AXBUF);
  1496.     else
  1497. #endif
  1498.         (void) pax25 (here, Mycall);
  1499.     if (initial) {
  1500.         (void) DisplayFile (AskhomeFile, m->user);
  1501.         if (Mbhome != NULLCHAR)
  1502.             tputs (Mbhome);
  1503.         strncpy (name, here, 80);
  1504.         if ((cp = strchr (name, '.')) != NULLCHAR)
  1505.             *cp = '\0';
  1506.         m->home = strdup (name);
  1507.     } else
  1508.         tprintf (changehome_str, (m->home) ? m->home : here);
  1509.     tputs ("\nHOME BBS>\n");
  1510.     if (mbxrecvline (m) == -1)
  1511.         return;
  1512.     for (cp = m->line; isspace (*cp); ++cp)
  1513.         ;
  1514.     if (*cp && *cp != '\n') {
  1515.         free (m->home);
  1516.         (void) strlwr (cp);
  1517.         m->home = strdup (cp);
  1518.         if ((cp = strchr (m->home, '.')) != NULLCHAR)
  1519.             *cp = '\0';
  1520.         m->change |= CHG_WP;
  1521.     }
  1522.     tprintf (homeset_str, (m->home) ? m->home : here);
  1523.     updatedefaults (m, 0);
  1524. #endif
  1525. }
  1526.  
  1527.  
  1528.  
  1529. #if (defined(ASKHOME) || defined(WPAGES))
  1530. int
  1531. dobbshome (int argc, char *argv[], void *p)
  1532. {
  1533. struct mbx *m;
  1534. char *orgname, *orghome;
  1535.  
  1536.     m = (struct mbx *) p;
  1537.     if (argc > 1 && (m->privs & SYSOP_CMD)) {
  1538.         if (argc == 2)
  1539.             return (dombuserinfo (argc, argv, p));
  1540.         if (argc > 3 || argv[2][0] != '@') {
  1541.             tputs (homesyntax);
  1542.             return (0);
  1543.         }
  1544.         orgname = strdup (m->name);
  1545.         orghome = m->home;
  1546.         strncpy (m->name, argv[1], 20);
  1547.         m->home = argv[2];
  1548.         updatedefaults (m, 1);
  1549.         strncpy (m->name, orgname, 20);
  1550.         m->home = orghome;
  1551.         free (orgname);
  1552.     } else
  1553.         askhome (m, 0);
  1554.     return 0;
  1555. }
  1556. #endif /* ASKHOME || WPAGES */
  1557.  
  1558.  
  1559.  
  1560. #ifdef USERLOG
  1561. void 
  1562. askrealname (struct mbx *m, int initial)
  1563. {
  1564. char *cp;
  1565. char name[80];
  1566. char *callnm;
  1567.  
  1568.     if (initial) {
  1569.         callnm = mblookname (NULLMBX, m->name);
  1570.         if (m->privs & IS_BBS) {
  1571.             m->realname = strdup (m->name);
  1572.             return;
  1573.         }
  1574.         if (callnm) {
  1575.             m->realname = strdup (&callnm[1]);
  1576.             free (callnm);
  1577.             m->update = 1;
  1578.             tprintf (realname_as, callnm);
  1579.         } else
  1580.             m->realname = strdup ("()");
  1581.  
  1582.         tprintf (realname_str, (callnm) ? "change" : "set");
  1583.         return;
  1584.     }
  1585.     tprintf (realname_change, (!m->realname || !strcmp (m->realname, "()")) ? "unknown" : m->realname);
  1586.     tputs ("\nREAL NAME>\n");
  1587.     if (mbxrecvline (m) == -1)
  1588.         return;
  1589.     cp = skipwhite (m->line);
  1590.     if (*cp && *cp != '\n') {
  1591.         free (m->realname);
  1592.         sprintf (name, "(%s)", cp);
  1593.         m->realname = strdup (name);
  1594.         m->change |= CHG_WP;
  1595.     }
  1596.     tprintf (realname_set, (m->realname && strcmp (m->realname, "()")) ? m->realname : "unknown");
  1597.     m->update = 1;
  1598. }
  1599.  
  1600.  
  1601.  
  1602. int
  1603. dorealname (int argc, char *argv[], void *p)
  1604. {
  1605. struct mbx *m;
  1606. char *orgname, *orgreal;
  1607.  
  1608.     m = (struct mbx *) p;
  1609.     if (argc > 1 && (m->privs & SYSOP_CMD)) {
  1610.         if (argc == 2)
  1611.             return (dombuserinfo (argc, argv, p));
  1612.         if (argc > 3) {
  1613.             tputs (realname_syntax);
  1614.             return (0);
  1615.         }
  1616.         orgname = strdup (m->name);
  1617.         orgreal = m->realname;
  1618.         strncpy (m->name, argv[1], 20);
  1619.         m->realname = argv[2];
  1620.         updatedefaults (m, 2);
  1621.         strncpy (m->name, orgname, 20);
  1622.         m->realname = orgreal;
  1623.         free (orgname);
  1624.     } else
  1625.         askrealname (m, 0);
  1626.     return 0;
  1627. }
  1628. #endif
  1629.  
  1630.  
  1631.  
  1632. static int DiffUsers = 0;
  1633.  
  1634.  
  1635.  
  1636. time_t
  1637. loguser (struct mbx *m)
  1638. {
  1639. register struct pu *pu;
  1640. time_t t;
  1641. #ifdef USERLOG
  1642. FILE *Ufile = NULLFILE;
  1643. char buf[256];
  1644. char *cp;
  1645. int found = 0;
  1646. time_t laston = 0;
  1647. int xpert = 0;
  1648. #endif
  1649.  
  1650.     (void) time (&t);
  1651.     m->logontime = (long) t;
  1652.     if ((pu = pu_lookup (m->name)) == NULLPU) {    /* not 'known' user */
  1653. #ifdef POOLED
  1654.         pu = (struct pu *) pool_alloc (&Pu_pool);
  1655. #else
  1656.         pu = (struct pu *) callocw (1, sizeof (struct pu));
  1657.  
  1658. #endif
  1659.         strncpy (pu->name, m->name, 20);
  1660.         pu->next = Pu;
  1661.         Pu = pu;
  1662.         DiffUsers++;    /* A new guy */
  1663.     }
  1664.     pu->time = secclock ();
  1665.     pu->number++;
  1666.  
  1667. #ifdef USERLOG
  1668.     /* Now get options from the userdefaults file, and add timestamp */
  1669.     if (!(m->sid & MBX_SID)) {    /* only if not a bbs */
  1670.         sprintf (buf, "%s", UDefaults);
  1671.         if ((Ufile = fopen (buf, "r+")) == NULLFILE) {
  1672.             /* default file doesn't exist, create it */
  1673.             if ((Ufile = fopen (buf, "w")) == NULLFILE)
  1674.                 return (time_t) - 1;
  1675.             /* Add this user as first one,
  1676.              * default uses Area indication
  1677.              */
  1678.             m->home = strdup ("-");
  1679.  
  1680.             (void) time (&t);
  1681.             sprintf (buf, "%s @%s () %lu M%d %s%s%s%s%s C%c\n",
  1682.                  m->name,
  1683.                  (m->home && Hostname && strnicmp (m->home, Hostname, strlen (m->home)))
  1684.                  ? m->home : "", t, m->morerows,
  1685.                  (m->privs & IS_BBS) ? "" : (Usearea) ? "A" : "",
  1686.                  (Usehold) ? "H" : "",
  1687.                  (Usenrid) ? "N" : "",
  1688.                  (Usescan) ? "S" : "",
  1689.                  (m->sid & MBX_EXPERT) ? "X" : "",
  1690.                  (m->family == AF_AX25) ? 'A' : \
  1691.                  ((m->family == AF_NETROM) ? 'N' : 'T'));
  1692.             fputs (buf, Ufile);
  1693.             (void) fclose (Ufile);
  1694.             m->realname = NULLCHAR;
  1695.             if (!(m->privs & IS_BBS) && Usearea)
  1696.                 m->sid |= MBX_AREA;
  1697.             if (Usenrid)
  1698.                 m->sid |= MBX_NRID;
  1699.             if (Usescan)
  1700.                 m->sid |= MBX_STATS;
  1701.             return laston;
  1702.         }
  1703.         /* Find user in the default file */
  1704.         while (!found) {
  1705.             if (fgets (buf, sizeof (buf), Ufile) == NULLCHAR)
  1706.                 break;
  1707.             if ((cp = strchr (buf, ' ')) == NULLCHAR)
  1708.                 continue;
  1709.             *cp++ = '\0';
  1710.             if (!stricmp (m->name, buf)) {
  1711.                 /* found user, now scan the options used */
  1712.                 found = 1;
  1713.                 (void) fclose (Ufile);
  1714.                 if (*cp == '@') {
  1715.                     char *cp2;
  1716.  
  1717.                     if ((cp2 = strchr (cp++, ' ')) != NULLCHAR) {
  1718.                         *cp2++ = '\0';
  1719.                         if (*cp)
  1720.                             m->home = strdup (cp);
  1721.                         cp = cp2;
  1722.                     }
  1723.                 } else
  1724.                     m->home = strdup ("-");
  1725.                 cp = skipwhite (cp);
  1726.                 m->realname = NULLCHAR;
  1727.                 if (*cp == '(') {
  1728.                     char *cp2;
  1729.  
  1730.                     if ((cp2 = strchr (cp, ')')) != NULLCHAR) {
  1731.                         cp2++;
  1732.                         *cp2++ = '\0';
  1733.                         m->realname = strdup (cp);
  1734.                         cp = cp2;
  1735.                     }
  1736.                 }
  1737.                 cp = skipwhite (cp);
  1738.                 laston = atol (cp);
  1739.                 while (*cp != ' ')    /* now skip the laston time */
  1740.                     cp++;
  1741.                 while (*cp != '\0') {
  1742.                     while (*cp == ' ')    /*skip blanks*/
  1743.                         cp++;
  1744.                     switch (*cp) {
  1745.                         case 'C':
  1746.                             /* All options end BEFORE the CT/CN or CA */
  1747.                             *(cp + 1) = '\0';
  1748.                             break;
  1749.                         case 'H':
  1750.                             m->sid |= MBX_HOLD;
  1751.                             break;
  1752.                         case 'D':
  1753.                             m->sid |= MBX_DELEGATE;
  1754.                             break;
  1755.                         case 'M':
  1756.                             cp++;
  1757.                             m->morerows = atoi (cp);
  1758.                             break;
  1759.                         case 'A':
  1760.                             m->sid |= MBX_AREA;
  1761.                             break;
  1762.                         case 'G':
  1763.                             m->sid |= MBX_GFX;
  1764.                             m->usecolor = 1;
  1765.                             break;
  1766.                         case 'X':
  1767.                             m->sid |= MBX_EXPERT;
  1768.                             xpert = 1;
  1769.                             break;
  1770.                         case 'N':
  1771.                             m->sid |= MBX_NRID;
  1772.                             break;
  1773.                         case 'R':
  1774.                             m->sid |= MBX_RDMOTD;
  1775.                             break;
  1776.                         case 'S':
  1777.                             m->sid |= MBX_STATS;
  1778.                             break;
  1779.                         case 'L':
  1780.                             m->sid |= MBX_TNOS;
  1781.                             break;
  1782.                         default:
  1783.                             break;
  1784.                     }
  1785.                     cp++;
  1786.                 }
  1787.             }
  1788.         }        /* while(!found)*/
  1789.         if (found) {
  1790.             /* add the new timestamp to the defaults file */
  1791.             updatedefaults (m, 0);
  1792.             if (!xpert)
  1793.                 m->sid &= ~MBX_EXPERT;
  1794.             return laston;
  1795.         } else {
  1796.             /* a new one, add to the end (where we now should be!)*/
  1797.             m->home = strdup ("-");
  1798.             (void) time (&t);
  1799.             sprintf (buf, "%s @%s () %lu M%d %s%s%s%s%s C%c\n",
  1800.                  m->name,
  1801.                  (m->home && Hostname && strnicmp (m->home, Hostname, strlen (m->home)))
  1802.                  ? m->home : "", t, m->morerows,
  1803.                  (m->privs & IS_BBS) ? "" : (Usearea) ? "A" : "",
  1804.                  (Usehold) ? "H" : "",
  1805.                  (Usenrid) ? "N" : "",
  1806.                  (Usescan) ? "S" : "",
  1807.                  (m->sid & MBX_EXPERT) ? "X" : "",
  1808.                  (m->family == AF_AX25) ? 'A' : \
  1809.                  ((m->family == AF_NETROM) ? 'N' : 'T'));
  1810.             if (Ufile != NULLFILE)    {    /*lint !e644 */
  1811.                 fputs (buf, Ufile);
  1812.                 (void) fclose (Ufile);
  1813.             }
  1814.             m->realname = NULLCHAR;
  1815.             if (!(m->privs & IS_BBS) && Usearea)
  1816.                 m->sid |= MBX_AREA;
  1817.             if (Usenrid)
  1818.                 m->sid |= MBX_NRID;
  1819.             if (Usescan)
  1820.                 m->sid |= MBX_STATS;
  1821.             return laston;
  1822.         }
  1823.     }            /* if not bbs */
  1824. #endif /* USERLOG */
  1825.     return (time_t) - 1;
  1826. }
  1827.  
  1828.  
  1829.  
  1830. /*List all past users of the mailbox */
  1831. int
  1832. dombpast (int argc, char *argv[], void *p OPTIONAL)
  1833. {
  1834. register struct pu *pu;
  1835. int col = 0;
  1836. int maxcount = 10000;    /* Large enough :-) */
  1837. int count = 0;
  1838.  
  1839.     if (argc > 1)
  1840.         maxcount = atoi (argv[1]) - 1;
  1841.  
  1842.     tputs (past_header);
  1843.     for (pu = Pu; pu != NULLPU; pu = pu->next) {
  1844.         if (col)
  1845.             tputs (" : ");
  1846.         tprintf ("%-10s    %-4d    %12s", pu->name, pu->number, \
  1847.              tformat (secclock () - pu->time));
  1848.         count++;
  1849.         if (count > maxcount)
  1850.             break;
  1851.         if (col) {
  1852.             col = 0;
  1853.             tputc ('\n');
  1854.         } else
  1855.             col = 1;
  1856.     }
  1857.     if (col)
  1858.         tputc ('\n');
  1859.     tputc ('\n');
  1860.     return 0;
  1861. }
  1862.  
  1863.  
  1864.  
  1865. static void
  1866. smtpqueuecheck ()
  1867. {
  1868. struct ffblk block;
  1869. int done, i = 0;
  1870. char buffer[1024];
  1871.  
  1872.     sprintf (buffer, "%s/*.wrk", Mailqdir);
  1873.     done = findfirst (buffer, &block, 0x3F);
  1874.     while (!done) {
  1875.         i++;
  1876.         done = findnext (&block);
  1877.     }
  1878.     if (i)
  1879.         tprintf (queued_str, i);
  1880. }
  1881.  
  1882.  
  1883.  
  1884. int
  1885. douptime (int argc OPTIONAL, char *argv[] OPTIONAL, void *p OPTIONAL)
  1886. {
  1887.     tprintf ("Up: %s\n", tformat (secclock ()));
  1888.     return 0;
  1889. }
  1890.  
  1891.  
  1892.  
  1893. int
  1894. dombmailstats (int argc OPTIONAL, char *argv[] OPTIONAL, void *p OPTIONAL)
  1895. {
  1896. #ifndef UNIX
  1897.     tputs ("Mem: ");
  1898.     mbmemory ();
  1899. #endif
  1900.  
  1901.     tprintf (ms_logins, Totallogins, BBSlogins);
  1902. #ifdef CONVERS
  1903.     tprintf (" - CONF: %d", Conflogins);
  1904. #endif
  1905. #ifdef TUTOR
  1906.     tprintf (" - TUTOR: %d - INFO: %d - NEWS: %d", Tutorlogins[0], Tutorlogins[1], Tutorlogins[2]);
  1907. #endif
  1908.     tputs (")\n");
  1909.     (void) douptime (0, (char **) 0, (void *) 0);
  1910.     tprintf (users_count, BbsUsers, DiffUsers);
  1911.  
  1912. #ifdef MBFWD
  1913.     tprintf ("Users sent: %d\nUsers read: %d\nReceived  : %d\nForwarded : %d\n",
  1914.          MbSent, MbRead, MbRecvd, MbForwarded);
  1915. #else
  1916.     tprintf ("Users sent: %d\nUsers read: %d\nReceived  : %d\n", MbSent, MbRead, MbRecvd);
  1917. #endif
  1918. #ifdef EXPIRY
  1919.     if (ExpireActive)
  1920.         tprintf ("Expiration of public area%s %s%s%sin progress\n",
  1921.             ExpireArea ? "" : "s", ExpireArea ? "\'" : "",
  1922.             ExpireArea ? ExpireArea : "", ExpireArea ? "\' " : "");
  1923.     else if (ExpireLast)
  1924.         tprintf ("Last Expiration: %s", ptime (&ExpireLast));
  1925. #endif
  1926.     smtpqueuecheck ();
  1927. #ifdef MAILFOR
  1928.     (void) domftimer (1, (char **) 0, (void *) 0);
  1929. #endif
  1930.     return 0;
  1931. }
  1932.  
  1933.  
  1934.  
  1935. #ifdef USERLOG
  1936. extern int DTranslate;        /* do IP address to domain name translation */
  1937.  
  1938.  
  1939. /* Search for info on a certain user in the users.dat file */
  1940. int
  1941. dombuserinfo (int argc OPTIONAL, char *argv[], void *p)
  1942. {
  1943. FILE *Ufile;
  1944. char buf[MBXLINE];
  1945. int found = 0;
  1946. time_t t;
  1947. struct tm *lt;
  1948. char *cp, *home = 0, *cp3 = 0;
  1949. char const *cp2;
  1950. char *cp4;
  1951. struct mbx *m;
  1952. char *realname;
  1953. uint32 addr;
  1954. int trans;
  1955.  
  1956.     m = (struct mbx *) p;
  1957.  
  1958.     if ((Ufile = fopen (UDefaults, "r")) == NULLFILE) {
  1959.         tputs ("Can't find user data\n");
  1960.         return 0;
  1961.     }
  1962.     while (!found && (fgets (buf, MBXLINE, Ufile) != NULLCHAR)) {
  1963.         if ((cp = strchr (buf, ' ')) == NULLCHAR)
  1964.             continue;
  1965.         *cp++ = '\0';
  1966.         if (!stricmp (buf, argv[1])) {    /* Found it ! */
  1967.             home = Hostname;
  1968.             if ((cp3 = strchr (cp, ' ')) != NULLCHAR)
  1969.                 *cp3++ = '\0';
  1970.             if (*cp == '@') {
  1971.                 cp++;
  1972.                 if (*cp)
  1973.                     home = cp;
  1974.             }
  1975.             cp = skipwhite (cp3);
  1976.             realname = NULLCHAR;
  1977.             if (*cp == '(') {
  1978.                 if ((cp4 = strchr (cp, ')')) != NULLCHAR) {
  1979.                     cp4++;
  1980.                     *cp4++ = '\0';
  1981.                     realname = cp;
  1982.                     cp = cp4;
  1983.                 }
  1984.             }
  1985.             cp = skipwhite (cp);
  1986.  
  1987.             t = atol (cp);
  1988.             lt = localtime (&t);
  1989.             cp2 = "TELNET";
  1990.             if ((cp = strchr (cp, 'C')) != NULLCHAR) {
  1991.                 cp++;
  1992.                 /* How was the connection made ? */
  1993.                 switch (*cp) {
  1994.                     case 'A':
  1995.                         cp2 = "AX.25";
  1996.                         break;
  1997.                     case 'N':
  1998.                         cp2 = "NETROM";
  1999.                         break;
  2000.                     default:
  2001.                         break;
  2002.                 }
  2003.             }
  2004.             tprintf (info_on, argv[1], (realname) ? realname : "");
  2005.             if (m == NULLMBX || m->stype == 'L')
  2006.                 tprintf ("%s last connected via %s on %s", argv[1], cp2, asctime (lt));
  2007. #ifdef ASKHOME
  2008.             tprintf ("%s's HOME BBS", argv[1]);
  2009.             if (*home == '-')
  2010.                 tputs (" is unknown!\n");
  2011.             else {
  2012.                 strncpy (buf, home, MBXLINE);
  2013.                 if ((cp = strchr (buf, '.')) != 0)
  2014.                     *cp = 0;
  2015.                 (void) strupr (buf);
  2016.                 tprintf (": '%s'\n", buf);
  2017.             }
  2018. #endif
  2019.             found = 1;
  2020.         }
  2021.     }
  2022.     (void) fclose (Ufile);
  2023.     cp2 = wpage_exp (strdup (argv[1]), 1, 1);
  2024.     if (strchr (cp2, '.')) {
  2025.         cp4 = strdup (cp2);
  2026.         (void) strupr (cp4);
  2027.         tprintf ("%s's WHITE PAGES: '%s'\n", argv[1], cp4);
  2028.         free (cp4);
  2029.     } else if (home && Hostname && home == Hostname) {
  2030.         tprintf ("%s's WHITE PAGES: '", argv[1]);
  2031.         sprintf (buf, "%s@", argv[1]);
  2032.         (void) pax25 (&buf[strlen (buf)], Mycall);
  2033.         if ((cp = strpbrk (buf, DIGI_IDS)) != NULLCHAR)
  2034.             *cp = '\0';    /* remove SSID */
  2035.         (void) strupr (buf);
  2036.         tputs (buf);
  2037. #ifdef MBFWD
  2038.         sprintf (buf, "%s%s'\n", (Mbhaddress != NULLCHAR) ? "." : "",
  2039.              (Mbhaddress != NULLCHAR) ? Mbhaddress : "");
  2040. #else
  2041.         sprintf (buf, "'\n");
  2042. #endif
  2043.         (void) strupr (buf);
  2044.         tputs (buf);
  2045.     }
  2046.     free (cp2);
  2047.     if ((addr = resolve (argv[1])) != 0) {
  2048.         trans = DTranslate;    /* Save IP address translation state */
  2049.         DTranslate = 0;    /* Force output to be numeric IP addr */
  2050.         tprintf (ipaddress_str, argv[1], inet_ntoa (addr));
  2051.         DTranslate = trans;    /* Restore original state */
  2052.     }
  2053.     if (!found)
  2054.         tprintf (nolocal_str, argv[1]);
  2055.     return 0;
  2056. }
  2057. #endif
  2058.  
  2059.  
  2060.  
  2061. static const char *MBstates[] =
  2062. {
  2063.     "Logging in", "Idle", "Sending message", "Sending message",
  2064.     "Reverse Forwarding", "Attempting Forward", "Forwarding",
  2065.     "Using gateway", "Reading message", "Uploading file",
  2066.     "Downloading file", "Convers mode", "Chatting with sysop",
  2067.     "Listing files", "Attempting Sysop mode", "Sysop mode",
  2068.     "Xmodem Receiving", "Xmodem Sending", "Being Tutored",
  2069.     "Node (idle)", "Unknown state"
  2070. };
  2071.  
  2072.  
  2073.  
  2074. const char *
  2075. displayMBstatus (int state, int issysop)
  2076. {
  2077.     /* Only show callers with sysop-privs who is sysop-mode!
  2078.          * This prevents users from easily learning who's
  2079.          * got SYSOP privs
  2080.          */
  2081.     if (!issysop && (state == MBX_SYSOPTRY || state == MBX_SYSOP))
  2082.         state = MBX_CMD;
  2083.     if (state < 0 || state > MBX_MAXSTATE)
  2084.         state = MBX_MAXSTATE + 1;
  2085.     return MBstates[state];
  2086. }
  2087.  
  2088.  
  2089.  
  2090. int
  2091. dombusers (int argc, char *argv[], void *p)
  2092. {
  2093. register struct mbx *m, *caller;
  2094. int i, len, nerf;
  2095. char *cp, *cp1, fsocket[MAXSOCKSIZE];
  2096. char upl[60], down[60];
  2097. struct usock *up, *up1, *up2;
  2098. int s;
  2099. time_t elapsedtime;
  2100. #ifdef NETROM
  2101. struct nrroute_tab *np;
  2102. char temp[AXBUF], *cp2, *cp3;
  2103. #endif
  2104.  
  2105.     caller = (struct mbx *) p;
  2106.  
  2107. #ifdef MAILCMDS
  2108.     if (caller->stype == 'H' || caller->stype == 'P' || caller->stype == 'T' || caller->stype == 'A')
  2109.         return dodelmsg (argc, argv, p);
  2110. #endif
  2111.  
  2112.     if (caller->privs & ALL_AREAS)
  2113.         return 0;    /* can't do this in all areas */
  2114.  
  2115.     if (caller->stype == 'S')
  2116.         return dombmailstats (argc, argv, p);
  2117.  
  2118.     if (caller->stype == 'F' && (caller->privs & SYSOP_CMD)) {
  2119.         if (argc < 3) {
  2120.             tputs ("Syntax: MF msg# BBSname\n");
  2121.             return 0;
  2122.         }
  2123.         s = atoi (argv[1]);
  2124.         if (!s || (caller->nmsgs < s))
  2125.             tputs (message_oor);
  2126.         else
  2127.             updateFwd (argv[2], caller->area, caller->mbox[s].bid, caller->mbox[s].size);
  2128.         return 0;
  2129.     }
  2130. #ifdef MBFWD
  2131.     if (caller->stype == 'K' && (caller->privs & SYSOP_CMD)) {
  2132.         if (argc > 1)
  2133.             return dombkickone (argc, argv, p);
  2134.         else
  2135.             return dombkick (argc, argv, p);
  2136.     }
  2137. #endif
  2138.  
  2139. #ifdef EXPIRY
  2140.     if (caller->stype == 'X' && (caller->privs & SYSOP_CMD)) {
  2141.         Expiretick (NULL);
  2142.         return 0;
  2143.     }
  2144. #endif
  2145. #ifdef MAILCMDS
  2146.     if ((caller->stype == 'W' || caller->stype == 'M' || caller->stype == 'C') && (caller->privs & SYSOP_CMD))
  2147.         return dombmovemail (argc, argv, p);
  2148. #endif
  2149.     if (caller->stype == 'R') {
  2150.         FILE *fp;
  2151.         char *from, *to = NULLCHAR, *file, msgtype;
  2152.  
  2153.         if (!(caller->privs & SYSOP_CMD)) {
  2154.             tputs ("Only available to SYSOPs, sorry!\n");
  2155.             return 0;
  2156.         }
  2157.         if (argc < 4 || argc > 5) {
  2158.             tputs (mr_syntax);
  2159.             return 0;
  2160.         }
  2161.         if ((file = permtest (caller->path, caller->privs, argv[2], RETR_CMD, NULLCHAR, 0)) == NULLCHAR)
  2162.             return 0;
  2163.  
  2164.         if ((fp = fopen (file, READ_TEXT)) != NULLFILE) {
  2165.             from = host_or_wpage_exp (strdup ((argc == 5) ? argv[4] : caller->name), 1, 0, &nerf);
  2166.             msgtype = (char) toupper (argv[1][0]);
  2167.             if (msgtype != 'B')
  2168.                 to = host_or_wpage_exp (strdup (argv[3]), 1, 0, &nerf);
  2169.             tputs ("Subject:\n");
  2170.             if (mbxrecvline (caller) != -1) {
  2171.                 (void) rdaemon (fp, NULLCHAR, from, to, caller->line, msgtype, 0);
  2172.                 tputs ("Message queued\n");
  2173.                 smtptick (NULL);    /* wake up SMTP to send mail */
  2174.             }
  2175.             (void) fclose (fp);
  2176.             free (from);
  2177.             free (to);
  2178.         } else
  2179.             tprintf ("Unable to open file '%s'\n", file);
  2180.         free (file);
  2181.         return 0;
  2182.     }
  2183.     if (caller->stype == 'L')
  2184. #ifdef USERLOG
  2185.         if (argc > 1) {
  2186.             for (i = 0; i < (int) strlen (argv[1]); i++) {
  2187.                 if (!isdigit (argv[1][i]))
  2188.                     return dombuserinfo (argc, argv, p);
  2189.             }
  2190.             return dombpast (argc, argv, p);
  2191.         } else
  2192. #endif
  2193.             return dombpast (argc, argv, p);
  2194.  
  2195.     tputs ("Users:\n");
  2196.  
  2197.     for (i = 0; i < NUMMBX; i++) {
  2198.         if ((m = Mbox[i]) != NULLMBX) {
  2199.             len = MAXSOCKSIZE;
  2200.             if (getpeername (m->user, fsocket, &len) != -1)
  2201.                 cp = strdup (psocket (fsocket));
  2202.             else
  2203.                 cp = strdup ("unknown");
  2204.  
  2205.             upl[0] = '\0';
  2206.             down[0] = '\0';
  2207.  
  2208. #if 0
  2209.             switch (m->family) {    /* UPLINK */
  2210. #else
  2211.             up2 = itop (m->user);
  2212.             if (up2 == NULLUSOCK)
  2213.                 continue;
  2214.             switch (up2->type) {    /* UPLINK */
  2215. #endif
  2216. #ifdef AX25
  2217. #if 0
  2218.                 case AF_AX25:
  2219. #else
  2220.                 case TYPE_AX25I:
  2221.                 case TYPE_AX25UI:
  2222. #endif
  2223.                     sprintf (upl, Uplink, cp);
  2224.                     break;
  2225. #endif
  2226. #ifdef NETROM
  2227. #if 0
  2228.                 case AF_NETROM:
  2229. #else
  2230.                 case TYPE_NETROML3:
  2231.                 case TYPE_NETROML4:
  2232. #endif
  2233.                     if ((cp1 = strchr (cp, ' ')) == NULLCHAR)
  2234.                         continue;
  2235.                     *cp1 = '\0';
  2236.                     cp1 += 3;
  2237.                     (void) setcall (temp, cp1);
  2238.                     np = find_nrroute (temp);
  2239.                     if (np != NULLNRRTAB)
  2240.                         cp2 = strdup (np->alias);
  2241.                     else
  2242.                         cp2 = strdup (" ");
  2243.                     if ((cp3 = strchr (cp2, ' ')) != NULLCHAR)
  2244.                         *cp3 = '\0';
  2245.                     /*
  2246.                     if(*cp2 == '#' || *cp2 == '\0')
  2247.                         sprintf(upl,incircuit,cp,"","",cp1);
  2248.                     else
  2249.                     */
  2250.  
  2251.                     /* show correct user name when outgoing forward over netrom
  2252.                      * problem caused by use of the '.C xxx' lines.
  2253.                      */
  2254.                     if (m->state == MBX_TRYING || m->state == MBX_FORWARD)
  2255.                         sprintf (upl, incircuit, m->name, cp2, ":", cp1);
  2256.                     else
  2257.                         sprintf (upl, incircuit, cp, cp2, ":", cp1);
  2258.                     free (cp2);
  2259.                     break;
  2260. #endif
  2261. #if 0
  2262.                 case AF_INET:
  2263. #else
  2264.                 case TYPE_TCP:
  2265.                 case TYPE_UDP:
  2266. #endif
  2267.                     if ((cp1 = strchr (cp, ':')) != NULLCHAR)
  2268.                         *cp1 = '\0';
  2269.                     sprintf (upl, Telnet, m->name, cp);
  2270.                     /* this fixes a problem where 127.0.0.1 is NOT
  2271.                        recognized as Local, but Telnet */
  2272.                     if (strnicmp (cp, "127.0.0.1", 9))
  2273.                         break;
  2274.                     /*lint -save -e616 * else, fall through and fix the problem */
  2275. #if 0
  2276.                 case AF_LOCAL:
  2277. #else
  2278.                 case TYPE_LOCAL_STREAM:
  2279.                 case TYPE_LOCAL_DGRAM:
  2280. #endif
  2281.                     sprintf (upl, Local, m->name, Hostname);
  2282.                     break;
  2283.                 default:
  2284. #if 0
  2285.                     strcpy (upl, "Connect");
  2286.                     break;
  2287. #else
  2288.                     /* if it gets here, it is NOT a valid user!
  2289.                      * We will NOT try to free the garbage, though
  2290.                      */
  2291.                     Mbox[i] = NULLMBX;
  2292.                     continue;
  2293. #endif
  2294.             /*lint -restore */
  2295.             }
  2296.             free (cp);
  2297.             if (m->state == MBX_TRYING)    /* forwarding session */
  2298.                 sprintf (upl, fwd_daemon, m->name);
  2299.             tprintf ("%-38.38s", upl);
  2300.  
  2301.             /* Show their elapsed time on system - KO4KS */
  2302.             elapsedtime = 0;
  2303.             if (m->state != MBX_LOGIN) {
  2304.                 (void) time ((time_t *) & elapsedtime);
  2305.                 elapsedtime -= m->logontime;
  2306.             }
  2307.             tprintf (" %10.10s", (m->state == MBX_TRYING) ? "" : tformat ((long) elapsedtime));
  2308.  
  2309.             /* Now show what they are doing - WG7J */
  2310.             if (m->state != MBX_GATEWAY)
  2311.                 tputs ("  -> ");
  2312.             switch (m->state) {
  2313.                 case MBX_GATEWAY:
  2314.                     for (s = SOCKBASE; s < Nusock + SOCKBASE; s++) {
  2315.                         if ((up = itop (s)) == NULLUSOCK || s == m->user)
  2316.                             continue;
  2317.                         up1 = itop (m->user);
  2318.                         if (up->owner == up1->owner) {
  2319.                             if (getpeername (s, fsocket, &len) != -1)
  2320.                                 cp = strdup (psocket (fsocket));
  2321.                             else
  2322.                                 cp = strdup ("unknown");
  2323.                             switch (up->type) {
  2324.                                 case TYPE_TCP:
  2325. #ifdef notdef
  2326.                                     if ((cp1 = strchr (cp, ':')) != NULLCHAR)
  2327.                                         *cp1 = '\0';
  2328. #endif
  2329.                                     sprintf (down, Telnetdown, cp);
  2330.                                     break;
  2331. #ifdef AX25
  2332.                                 case TYPE_AX25I:
  2333.                                     /*
  2334.                                     if((cp1 = strchr(cp,' ')) != NULLCHAR)
  2335.                                         *cp1 = '\0';
  2336.                                     */
  2337.                                     sprintf (down, Downlink, cp);
  2338.                                     break;
  2339. #endif
  2340. #ifdef NETROM
  2341.                                 case TYPE_NETROML4:
  2342.                                     /*get rid of usercall*/
  2343.                                     if ((cp1 = strchr (cp, ' ')) == NULLCHAR)
  2344.                                         continue;
  2345.                                     *cp1 = '\0';
  2346.                                     cp1 += 3;    /*get rid of ' @ '*/
  2347.                                     (void) setcall (temp, cp1);    /*get node call*/
  2348.                                     np = find_nrroute (temp);    /*find alias, if any*/
  2349.                                     if (np == NULLNRRTAB)
  2350.                                         cp2 = strdup ("???");
  2351.                                     else {
  2352.                                         cp2 = strdup (np->alias);
  2353.                                         if ((cp3 = strchr (cp2, ' ')) != NULLCHAR)
  2354.                                             *cp3 = '\0';
  2355.                                         /*
  2356.                                         memcpy(cp,m->call,AXALEN);
  2357.                                         cp[ALEN] ^= 0x1e;
  2358.                                         */
  2359.                                     }
  2360.                                     /*
  2361.                                     if(*cp2 == '#' || *cp2 == '\0')
  2362.                                         sprintf(down,outcircuit,"","",cp1);
  2363.                                     else
  2364.                                     */
  2365.                                     sprintf (down, outcircuit, cp2, ":", cp1);
  2366.                                     free (cp2);
  2367.                                     break;
  2368. #endif
  2369.                                 case TYPE_LOCAL_STREAM:
  2370.                                 case TYPE_LOCAL_DGRAM:
  2371.                                     sprintf (down, Local, m->name, Hostname);
  2372.                                     break;
  2373.                                 default:
  2374.                                     strcpy (down, "Connect");
  2375.                                     break;
  2376.                             }
  2377.                             free (cp);
  2378.                             tprintf ("<--> %s", down);
  2379.                             break;
  2380.                         }
  2381.                     }
  2382.                     if (!down[0])    /* couldn't find out where the gateway was TO! */
  2383.                         tputs ("<--> ??INVALID GATEWAY INFO??");
  2384.                     tputs ("\n");
  2385.                     break;
  2386.                 default:
  2387.                     tprintf ("%s\n", displayMBstatus (m->state, (caller->privs & SYSOP_CMD)));
  2388.             }
  2389.         }
  2390.     }
  2391.     tputc ('\n');
  2392.     return 0;
  2393. }
  2394.  
  2395.  
  2396.  
  2397. #if defined(TIPMAIL) && defined(ALLSERV)
  2398. static int
  2399. dotimeout (int argc, char *argv[], void *p OPTIONAL)
  2400. {
  2401.     return setuns (&Tiptimeout, tiptimeout_str, argc, argv);
  2402. }
  2403. #endif
  2404.  
  2405.  
  2406.  
  2407. #ifdef CALLBOOK
  2408. char *InetCallserver = NULLCHAR;
  2409. char *InetCallserverport = NULLCHAR;
  2410.  
  2411. int
  2412. doinetcallserver (int argc, char *argv[], void *p OPTIONAL)
  2413. {
  2414.     if (argc == 1) {
  2415.         if (InetCallserver != NULLCHAR)
  2416.             tprintf ("Server %s, on port %s\n", InetCallserver, InetCallserverport);
  2417.         else
  2418.             tputs ("Not set!\n");
  2419.         return 0;
  2420.     }
  2421.     if (argc == 2) {
  2422.         tputs (callusage);
  2423.         return 0;
  2424.     }
  2425.     /*Check validity of the parameters*/
  2426.     if (resolve (argv[1]) == (int32) 0) {
  2427.         tprintf (Badhost, argv[1]);
  2428.         return 0;
  2429.     }
  2430.     if (atoi (argv[2]) == (int) 0) {
  2431.         tprintf ("Bad port %s\n", argv[2]);
  2432.         return 0;
  2433.     }
  2434.     if (InetCallserver != NULLCHAR) {
  2435.         free (InetCallserver);
  2436.         free (InetCallserverport);
  2437.     }
  2438.     InetCallserver = strdup (argv[1]);
  2439.     InetCallserverport = strdup (argv[2]);
  2440.     return 0;
  2441. }
  2442. #endif /* CALLBOOK */
  2443.  
  2444.  
  2445.  
  2446. char *
  2447. cmd_line (int argc, char *argv[], char stype)
  2448. {
  2449. static char line[MBXLINE + 1];
  2450. int i;
  2451. char *cp;
  2452.  
  2453.     cp = line;
  2454.     sprintf (cp, "%s ", argv[0]);
  2455.     cp += strlen (cp);
  2456.     if (stype != ' ') {
  2457.         --cp;
  2458.         if (islower (*line))
  2459.             stype = (char) tolower (stype);
  2460.         sprintf (cp, "%c ", stype);
  2461.         cp += 2;
  2462.     }
  2463.     for (i = 1; i < argc; i++) {
  2464.         sprintf (cp, "%s ", argv[i]);
  2465.         cp += strlen (cp);
  2466.     }
  2467.     return line;
  2468. }
  2469.  
  2470.  
  2471.  
  2472. static int
  2473. dombcmd (int argc, char *argv[], void *p OPTIONAL)
  2474. {
  2475.     if (argc < 3)
  2476.         assoc_list (Mbcustom, 10, (argc == 1) ? NULLCHAR : argv[1]);
  2477.     else
  2478.         (void) assoc_addstr (&Mbcustom, argv[1], argv[2], 1);
  2479.  
  2480.     return 0;
  2481. }
  2482.  
  2483.  
  2484.  
  2485. #ifdef MAILCMDS
  2486. static int
  2487. dombbonly (int argc, char *argv[], void *p)
  2488. {
  2489.     return (dosetflag (argc, argv, p, BBS_ONLY, 1));
  2490. }
  2491. #endif
  2492.  
  2493.  
  2494.  
  2495. static int
  2496. dombuonly (int argc, char *argv[], void *p)
  2497. {
  2498.     return (dosetflag (argc, argv, p, USERS_ONLY, 1));
  2499. }
  2500.  
  2501.  
  2502.  
  2503. static int
  2504. dombsonly (int argc, char *argv[], void *p)
  2505. {
  2506.     return (dosetflag (argc, argv, p, SYSOP_ONLY, 1));
  2507. }
  2508.  
  2509.  
  2510.  
  2511. int
  2512. isaPBBShost (char *str)
  2513. {
  2514. int k;
  2515. char *cp;
  2516.  
  2517.     /* this routine returns 1 if it looks like an AX25 PBBS name,
  2518.        otherwise it returns 0 which means it is probably an IP hostname */
  2519.     for (k = 0; k < numcontinents; k++) {
  2520.         if (((cp = strstr (str, continents[k])) != NULLCHAR) && (*(cp - 1) == '.') && (*(cp - 5) == '.') && !cp[4])
  2521.             return 1;
  2522.     }
  2523.     return 0;
  2524. }
  2525.  
  2526.  
  2527. #ifdef ALLSERV
  2528. extern int CHAToneshotBypass;
  2529.  
  2530.  
  2531.  
  2532. int
  2533. dombchat (int argc OPTIONAL, char *argv[], void *p OPTIONAL)
  2534. {
  2535. int i;
  2536. struct mbx *m = NULLMBX;
  2537.  
  2538.     /* check the mailbox users */
  2539.     for (i = 0; i < NUMMBX; i++) {
  2540.         if ((m = Mbox[i]) != NULLMBX) {
  2541.             if (!stricmp (m->name, argv[1]))
  2542.                 break;
  2543.         }
  2544.     }
  2545.     if (m != NULLMBX && i != NUMMBX) {
  2546.         MAttended = TRUE;    /* force to attended */
  2547.         CHAToneshotBypass = 1;
  2548.         if (m->state == MBX_CMD) {
  2549.             usputc (m->user, '\007');
  2550.             usputs (m->user, sysopchat);
  2551.             usflush (m->user);
  2552.         }
  2553.         m->privs |= SYS_CHAT;
  2554.     } else
  2555.         tprintf (usernoton, argv[1]);
  2556.     return 0;
  2557. }
  2558. #endif
  2559.  
  2560.  
  2561. void
  2562. setMaintenance ()
  2563. {
  2564. int i;
  2565.  
  2566.     MBXMaint += 1;
  2567.     if (MBXMaintMode) {
  2568.         switch (MBXMaintClear) {
  2569.             case 1:/* Clear out the BBS - bump users */
  2570.                 for (i = 0; i < NUMMBX; i++) {
  2571.                     if (Mbox[i] != NULLMBX) {
  2572.                         if (MBXMaintStr) {
  2573.                             usprintf (Mbox[i]->user, "\n%s\n", MBXMaintStr);
  2574.                             usflush (Mbox[i]->user);
  2575.                             kpause (5000);
  2576.                         }
  2577.                         close_s (Mbox[i]->user);
  2578.                     }
  2579.                 }
  2580.                 break;
  2581.             default:
  2582.                 while (BbsUsers)
  2583.                     kpause (1000);
  2584.                 break;
  2585.         }
  2586.     }
  2587. }
  2588.  
  2589.  
  2590.  
  2591. void
  2592. clearMaintenance ()
  2593. {
  2594.     MBXMaint -= 1;
  2595. }
  2596.  
  2597.  
  2598.  
  2599. #ifdef EXPIRY
  2600. int
  2601. dombprune (int argc OPTIONAL, char *argv[] OPTIONAL, void *p OPTIONAL)
  2602. {
  2603.     if (newproc ("Pruning", 2048, mbpruning, 0, NULL, NULL, 0) == NULLPROC)
  2604.         log (-1, "Couldn't start Pruning process");
  2605.     return 0;
  2606. }
  2607.  
  2608.  
  2609. int
  2610. dombpruneage (int argc OPTIONAL, char *argv[] OPTIONAL, void *p OPTIONAL)
  2611. {
  2612.     return setint (&PruneAge, pruneage_str, argc, argv);
  2613. }
  2614.  
  2615.  
  2616. static void
  2617. mbpruning (int a OPTIONAL, void *v1 OPTIONAL, void *v2 OPTIONAL)
  2618. {
  2619. char buf[MBXLINE];
  2620. struct ffblk ff;
  2621. char *tmp;
  2622.  
  2623.     log (-1, "BBS Pruning process started");
  2624.     setMaintenance ();
  2625.     sprintf (buf, "%s/*.txt", Mailspool);
  2626.     if (findfirst (buf, &ff, 0) == 0) {
  2627.         do {
  2628.             kwait (NULL);    /* Let others run */
  2629.             if ((tmp = strchr (ff.ff_name, '.')) != NULLCHAR)
  2630.                 *tmp = '\0';
  2631.             if (!issysarea (ff.ff_name))
  2632.                 expire (ff.ff_name, -1);
  2633.         } while (findnext (&ff) == 0);
  2634.     }
  2635.     clearMaintenance ();
  2636.     log (-1, "BBS Pruning process completed");
  2637. }
  2638. #endif
  2639.  
  2640. #endif /* MAILBOX */
  2641.